]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/staging/tty/ip2/ip2main.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix common misspellings
[mirror_ubuntu-bionic-kernel.git] / drivers / staging / tty / ip2 / ip2main.c
1 /*
2 *
3 * (c) 1999 by Computone Corporation
4 *
5 ********************************************************************************
6 *
7 * PACKAGE: Linux tty Device Driver for IntelliPort family of multiport
8 * serial I/O controllers.
9 *
10 * DESCRIPTION: Mainline code for the device driver
11 *
12 *******************************************************************************/
13 // ToDo:
14 //
15 // Fix the immediate DSS_NOW problem.
16 // Work over the channel stats return logic in ip2_ipl_ioctl so they
17 // make sense for all 256 possible channels and so the user space
18 // utilities will compile and work properly.
19 //
20 // Done:
21 //
22 // 1.2.14 /\/\|=mhw=|\/\/
23 // Added bounds checking to ip2_ipl_ioctl to avoid potential terroristic acts.
24 // Changed the definition of ip2trace to be more consistent with kernel style
25 // Thanks to Andreas Dilger <adilger@turbolabs.com> for these updates
26 //
27 // 1.2.13 /\/\|=mhw=|\/\/
28 // DEVFS: Renamed ttf/{n} to tts/F{n} and cuf/{n} to cua/F{n} to conform
29 // to agreed devfs serial device naming convention.
30 //
31 // 1.2.12 /\/\|=mhw=|\/\/
32 // Cleaned up some remove queue cut and paste errors
33 //
34 // 1.2.11 /\/\|=mhw=|\/\/
35 // Clean up potential NULL pointer dereferences
36 // Clean up devfs registration
37 // Add kernel command line parsing for io and irq
38 // Compile defaults for io and irq are now set in ip2.c not ip2.h!
39 // Reworked poll_only hack for explicit parameter setting
40 // You must now EXPLICITLY set poll_only = 1 or set all irqs to 0
41 // Merged ip2_loadmain and old_ip2_init
42 // Converted all instances of interruptible_sleep_on into queue calls
43 // Most of these had no race conditions but better to clean up now
44 //
45 // 1.2.10 /\/\|=mhw=|\/\/
46 // Fixed the bottom half interrupt handler and enabled USE_IQI
47 // to split the interrupt handler into a formal top-half / bottom-half
48 // Fixed timing window on high speed processors that queued messages to
49 // the outbound mail fifo faster than the board could handle.
50 //
51 // 1.2.9
52 // Four box EX was barfing on >128k kmalloc, made structure smaller by
53 // reducing output buffer size
54 //
55 // 1.2.8
56 // Device file system support (MHW)
57 //
58 // 1.2.7
59 // Fixed
60 // Reload of ip2 without unloading ip2main hangs system on cat of /proc/modules
61 //
62 // 1.2.6
63 //Fixes DCD problems
64 // DCD was not reported when CLOCAL was set on call to TIOCMGET
65 //
66 //Enhancements:
67 // TIOCMGET requests and waits for status return
68 // No DSS interrupts enabled except for DCD when needed
69 //
70 // For internal use only
71 //
72 //#define IP2DEBUG_INIT
73 //#define IP2DEBUG_OPEN
74 //#define IP2DEBUG_WRITE
75 //#define IP2DEBUG_READ
76 //#define IP2DEBUG_IOCTL
77 //#define IP2DEBUG_IPL
78
79 //#define IP2DEBUG_TRACE
80 //#define DEBUG_FIFO
81
82 /************/
83 /* Includes */
84 /************/
85
86 #include <linux/ctype.h>
87 #include <linux/string.h>
88 #include <linux/fcntl.h>
89 #include <linux/errno.h>
90 #include <linux/module.h>
91 #include <linux/signal.h>
92 #include <linux/sched.h>
93 #include <linux/timer.h>
94 #include <linux/interrupt.h>
95 #include <linux/pci.h>
96 #include <linux/mm.h>
97 #include <linux/slab.h>
98 #include <linux/major.h>
99 #include <linux/wait.h>
100 #include <linux/device.h>
101 #include <linux/mutex.h>
102 #include <linux/firmware.h>
103 #include <linux/platform_device.h>
104
105 #include <linux/tty.h>
106 #include <linux/tty_flip.h>
107 #include <linux/termios.h>
108 #include <linux/tty_driver.h>
109 #include <linux/serial.h>
110 #include <linux/ptrace.h>
111 #include <linux/ioport.h>
112
113 #include <linux/cdk.h>
114 #include <linux/comstats.h>
115 #include <linux/delay.h>
116 #include <linux/bitops.h>
117
118 #include <asm/system.h>
119 #include <asm/io.h>
120 #include <asm/irq.h>
121
122 #include <linux/vmalloc.h>
123 #include <linux/init.h>
124
125 #include <asm/uaccess.h>
126
127 #include "ip2types.h"
128 #include "ip2trace.h"
129 #include "ip2ioctl.h"
130 #include "ip2.h"
131 #include "i2ellis.h"
132 #include "i2lib.h"
133
134 /*****************
135 * /proc/ip2mem *
136 *****************/
137
138 #include <linux/proc_fs.h>
139 #include <linux/seq_file.h>
140
141 static DEFINE_MUTEX(ip2_mutex);
142 static const struct file_operations ip2mem_proc_fops;
143 static const struct file_operations ip2_proc_fops;
144
145 /********************/
146 /* Type Definitions */
147 /********************/
148
149 /*************/
150 /* Constants */
151 /*************/
152
153 /* String constants to identify ourselves */
154 static const char pcName[] = "Computone IntelliPort Plus multiport driver";
155 static const char pcVersion[] = "1.2.14";
156
157 /* String constants for port names */
158 static const char pcDriver_name[] = "ip2";
159 static const char pcIpl[] = "ip2ipl";
160
161 /***********************/
162 /* Function Prototypes */
163 /***********************/
164
165 /* Global module entry functions */
166
167 /* Private (static) functions */
168 static int ip2_open(PTTY, struct file *);
169 static void ip2_close(PTTY, struct file *);
170 static int ip2_write(PTTY, const unsigned char *, int);
171 static int ip2_putchar(PTTY, unsigned char);
172 static void ip2_flush_chars(PTTY);
173 static int ip2_write_room(PTTY);
174 static int ip2_chars_in_buf(PTTY);
175 static void ip2_flush_buffer(PTTY);
176 static int ip2_ioctl(PTTY, UINT, ULONG);
177 static void ip2_set_termios(PTTY, struct ktermios *);
178 static void ip2_set_line_discipline(PTTY);
179 static void ip2_throttle(PTTY);
180 static void ip2_unthrottle(PTTY);
181 static void ip2_stop(PTTY);
182 static void ip2_start(PTTY);
183 static void ip2_hangup(PTTY);
184 static int ip2_tiocmget(struct tty_struct *tty);
185 static int ip2_tiocmset(struct tty_struct *tty,
186 unsigned int set, unsigned int clear);
187 static int ip2_get_icount(struct tty_struct *tty,
188 struct serial_icounter_struct *icount);
189
190 static void set_irq(int, int);
191 static void ip2_interrupt_bh(struct work_struct *work);
192 static irqreturn_t ip2_interrupt(int irq, void *dev_id);
193 static void ip2_poll(unsigned long arg);
194 static inline void service_all_boards(void);
195 static void do_input(struct work_struct *);
196 static void do_status(struct work_struct *);
197
198 static void ip2_wait_until_sent(PTTY,int);
199
200 static void set_params (i2ChanStrPtr, struct ktermios *);
201 static int get_serial_info(i2ChanStrPtr, struct serial_struct __user *);
202 static int set_serial_info(i2ChanStrPtr, struct serial_struct __user *);
203
204 static ssize_t ip2_ipl_read(struct file *, char __user *, size_t, loff_t *);
205 static ssize_t ip2_ipl_write(struct file *, const char __user *, size_t, loff_t *);
206 static long ip2_ipl_ioctl(struct file *, UINT, ULONG);
207 static int ip2_ipl_open(struct inode *, struct file *);
208
209 static int DumpTraceBuffer(char __user *, int);
210 static int DumpFifoBuffer( char __user *, int);
211
212 static void ip2_init_board(int, const struct firmware *);
213 static unsigned short find_eisa_board(int);
214 static int ip2_setup(char *str);
215
216 /***************/
217 /* Static Data */
218 /***************/
219
220 static struct tty_driver *ip2_tty_driver;
221
222 /* Here, then is a table of board pointers which the interrupt routine should
223 * scan through to determine who it must service.
224 */
225 static unsigned short i2nBoards; // Number of boards here
226
227 static i2eBordStrPtr i2BoardPtrTable[IP2_MAX_BOARDS];
228
229 static i2ChanStrPtr DevTable[IP2_MAX_PORTS];
230 //DevTableMem just used to save addresses for kfree
231 static void *DevTableMem[IP2_MAX_BOARDS];
232
233 /* This is the driver descriptor for the ip2ipl device, which is used to
234 * download the loadware to the boards.
235 */
236 static const struct file_operations ip2_ipl = {
237 .owner = THIS_MODULE,
238 .read = ip2_ipl_read,
239 .write = ip2_ipl_write,
240 .unlocked_ioctl = ip2_ipl_ioctl,
241 .open = ip2_ipl_open,
242 .llseek = noop_llseek,
243 };
244
245 static unsigned long irq_counter;
246 static unsigned long bh_counter;
247
248 // Use immediate queue to service interrupts
249 #define USE_IQI
250 //#define USE_IQ // PCI&2.2 needs work
251
252 /* The timer_list entry for our poll routine. If interrupt operation is not
253 * selected, the board is serviced periodically to see if anything needs doing.
254 */
255 #define POLL_TIMEOUT (jiffies + 1)
256 static DEFINE_TIMER(PollTimer, ip2_poll, 0, 0);
257
258 #ifdef IP2DEBUG_TRACE
259 /* Trace (debug) buffer data */
260 #define TRACEMAX 1000
261 static unsigned long tracebuf[TRACEMAX];
262 static int tracestuff;
263 static int tracestrip;
264 static int tracewrap;
265 #endif
266
267 /**********/
268 /* Macros */
269 /**********/
270
271 #ifdef IP2DEBUG_OPEN
272 #define DBG_CNT(s) printk(KERN_DEBUG "(%s): [%x] ttyc=%d, modc=%x -> %s\n", \
273 tty->name,(pCh->flags), \
274 tty->count,/*GET_USE_COUNT(module)*/0,s)
275 #else
276 #define DBG_CNT(s)
277 #endif
278
279 /********/
280 /* Code */
281 /********/
282
283 #include "i2ellis.c" /* Extremely low-level interface services */
284 #include "i2cmd.c" /* Standard loadware command definitions */
285 #include "i2lib.c" /* High level interface services */
286
287 /* Configuration area for modprobe */
288
289 MODULE_AUTHOR("Doug McNash");
290 MODULE_DESCRIPTION("Computone IntelliPort Plus Driver");
291 MODULE_LICENSE("GPL");
292
293 #define MAX_CMD_STR 50
294
295 static int poll_only;
296 static char cmd[MAX_CMD_STR];
297
298 static int Eisa_irq;
299 static int Eisa_slot;
300
301 static int iindx;
302 static char rirqs[IP2_MAX_BOARDS];
303 static int Valid_Irqs[] = { 3, 4, 5, 7, 10, 11, 12, 15, 0};
304
305 /* Note: Add compiled in defaults to these arrays, not to the structure
306 in ip2.h any longer. That structure WILL get overridden
307 by these values, or command line values, or insmod values!!! =mhw=
308 */
309 static int io[IP2_MAX_BOARDS];
310 static int irq[IP2_MAX_BOARDS] = { -1, -1, -1, -1 };
311
312 MODULE_AUTHOR("Doug McNash");
313 MODULE_DESCRIPTION("Computone IntelliPort Plus Driver");
314 module_param_array(irq, int, NULL, 0);
315 MODULE_PARM_DESC(irq, "Interrupts for IntelliPort Cards");
316 module_param_array(io, int, NULL, 0);
317 MODULE_PARM_DESC(io, "I/O ports for IntelliPort Cards");
318 module_param(poll_only, bool, 0);
319 MODULE_PARM_DESC(poll_only, "Do not use card interrupts");
320 module_param_string(ip2, cmd, MAX_CMD_STR, 0);
321 MODULE_PARM_DESC(ip2, "Contains module parameter passed with 'ip2='");
322
323 /* for sysfs class support */
324 static struct class *ip2_class;
325
326 /* Some functions to keep track of what irqs we have */
327
328 static int __init is_valid_irq(int irq)
329 {
330 int *i = Valid_Irqs;
331
332 while (*i != 0 && *i != irq)
333 i++;
334
335 return *i;
336 }
337
338 static void __init mark_requested_irq(char irq)
339 {
340 rirqs[iindx++] = irq;
341 }
342
343 static int __exit clear_requested_irq(char irq)
344 {
345 int i;
346 for (i = 0; i < IP2_MAX_BOARDS; ++i) {
347 if (rirqs[i] == irq) {
348 rirqs[i] = 0;
349 return 1;
350 }
351 }
352 return 0;
353 }
354
355 static int have_requested_irq(char irq)
356 {
357 /* array init to zeros so 0 irq will not be requested as a side
358 * effect */
359 int i;
360 for (i = 0; i < IP2_MAX_BOARDS; ++i)
361 if (rirqs[i] == irq)
362 return 1;
363 return 0;
364 }
365
366 /******************************************************************************/
367 /* Function: cleanup_module() */
368 /* Parameters: None */
369 /* Returns: Nothing */
370 /* */
371 /* Description: */
372 /* This is a required entry point for an installable module. It has to return */
373 /* the device and the driver to a passive state. It should not be necessary */
374 /* to reset the board fully, especially as the loadware is downloaded */
375 /* externally rather than in the driver. We just want to disable the board */
376 /* and clear the loadware to a reset state. To allow this there has to be a */
377 /* way to detect whether the board has the loadware running at init time to */
378 /* handle subsequent installations of the driver. All memory allocated by the */
379 /* driver should be returned since it may be unloaded from memory. */
380 /******************************************************************************/
381 static void __exit ip2_cleanup_module(void)
382 {
383 int err;
384 int i;
385
386 del_timer_sync(&PollTimer);
387
388 /* Reset the boards we have. */
389 for (i = 0; i < IP2_MAX_BOARDS; i++)
390 if (i2BoardPtrTable[i])
391 iiReset(i2BoardPtrTable[i]);
392
393 /* The following is done at most once, if any boards were installed. */
394 for (i = 0; i < IP2_MAX_BOARDS; i++) {
395 if (i2BoardPtrTable[i]) {
396 iiResetDelay(i2BoardPtrTable[i]);
397 /* free io addresses and Tibet */
398 release_region(ip2config.addr[i], 8);
399 device_destroy(ip2_class, MKDEV(IP2_IPL_MAJOR, 4 * i));
400 device_destroy(ip2_class, MKDEV(IP2_IPL_MAJOR,
401 4 * i + 1));
402 }
403 /* Disable and remove interrupt handler. */
404 if (ip2config.irq[i] > 0 &&
405 have_requested_irq(ip2config.irq[i])) {
406 free_irq(ip2config.irq[i], (void *)&pcName);
407 clear_requested_irq(ip2config.irq[i]);
408 }
409 }
410 class_destroy(ip2_class);
411 err = tty_unregister_driver(ip2_tty_driver);
412 if (err)
413 printk(KERN_ERR "IP2: failed to unregister tty driver (%d)\n",
414 err);
415 put_tty_driver(ip2_tty_driver);
416 unregister_chrdev(IP2_IPL_MAJOR, pcIpl);
417 remove_proc_entry("ip2mem", NULL);
418
419 /* free memory */
420 for (i = 0; i < IP2_MAX_BOARDS; i++) {
421 void *pB;
422 #ifdef CONFIG_PCI
423 if (ip2config.type[i] == PCI && ip2config.pci_dev[i]) {
424 pci_disable_device(ip2config.pci_dev[i]);
425 pci_dev_put(ip2config.pci_dev[i]);
426 ip2config.pci_dev[i] = NULL;
427 }
428 #endif
429 pB = i2BoardPtrTable[i];
430 if (pB != NULL) {
431 kfree(pB);
432 i2BoardPtrTable[i] = NULL;
433 }
434 if (DevTableMem[i] != NULL) {
435 kfree(DevTableMem[i]);
436 DevTableMem[i] = NULL;
437 }
438 }
439 }
440 module_exit(ip2_cleanup_module);
441
442 static const struct tty_operations ip2_ops = {
443 .open = ip2_open,
444 .close = ip2_close,
445 .write = ip2_write,
446 .put_char = ip2_putchar,
447 .flush_chars = ip2_flush_chars,
448 .write_room = ip2_write_room,
449 .chars_in_buffer = ip2_chars_in_buf,
450 .flush_buffer = ip2_flush_buffer,
451 .ioctl = ip2_ioctl,
452 .throttle = ip2_throttle,
453 .unthrottle = ip2_unthrottle,
454 .set_termios = ip2_set_termios,
455 .set_ldisc = ip2_set_line_discipline,
456 .stop = ip2_stop,
457 .start = ip2_start,
458 .hangup = ip2_hangup,
459 .tiocmget = ip2_tiocmget,
460 .tiocmset = ip2_tiocmset,
461 .get_icount = ip2_get_icount,
462 .proc_fops = &ip2_proc_fops,
463 };
464
465 /******************************************************************************/
466 /* Function: ip2_loadmain() */
467 /* Parameters: irq, io from command line of insmod et. al. */
468 /* pointer to fip firmware and firmware size for boards */
469 /* Returns: Success (0) */
470 /* */
471 /* Description: */
472 /* This was the required entry point for all drivers (now in ip2.c) */
473 /* It performs all */
474 /* initialisation of the devices and driver structures, and registers itself */
475 /* with the relevant kernel modules. */
476 /******************************************************************************/
477 /* IRQF_DISABLED - if set blocks all interrupts else only this line */
478 /* IRQF_SHARED - for shared irq PCI or maybe EISA only */
479 /* SA_RANDOM - can be source for cert. random number generators */
480 #define IP2_SA_FLAGS 0
481
482
483 static const struct firmware *ip2_request_firmware(void)
484 {
485 struct platform_device *pdev;
486 const struct firmware *fw;
487
488 pdev = platform_device_register_simple("ip2", 0, NULL, 0);
489 if (IS_ERR(pdev)) {
490 printk(KERN_ERR "Failed to register platform device for ip2\n");
491 return NULL;
492 }
493 if (request_firmware(&fw, "intelliport2.bin", &pdev->dev)) {
494 printk(KERN_ERR "Failed to load firmware 'intelliport2.bin'\n");
495 fw = NULL;
496 }
497 platform_device_unregister(pdev);
498 return fw;
499 }
500
501 /******************************************************************************
502 * ip2_setup:
503 * str: kernel command line string
504 *
505 * Can't autoprobe the boards so user must specify configuration on
506 * kernel command line. Sane people build it modular but the others
507 * come here.
508 *
509 * Alternating pairs of io,irq for up to 4 boards.
510 * ip2=io0,irq0,io1,irq1,io2,irq2,io3,irq3
511 *
512 * io=0 => No board
513 * io=1 => PCI
514 * io=2 => EISA
515 * else => ISA I/O address
516 *
517 * irq=0 or invalid for ISA will revert to polling mode
518 *
519 * Any value = -1, do not overwrite compiled in value.
520 *
521 ******************************************************************************/
522 static int __init ip2_setup(char *str)
523 {
524 int j, ints[10]; /* 4 boards, 2 parameters + 2 */
525 unsigned int i;
526
527 str = get_options(str, ARRAY_SIZE(ints), ints);
528
529 for (i = 0, j = 1; i < 4; i++) {
530 if (j > ints[0])
531 break;
532 if (ints[j] >= 0)
533 io[i] = ints[j];
534 j++;
535 if (j > ints[0])
536 break;
537 if (ints[j] >= 0)
538 irq[i] = ints[j];
539 j++;
540 }
541 return 1;
542 }
543 __setup("ip2=", ip2_setup);
544
545 static int __init ip2_loadmain(void)
546 {
547 int i, j, box;
548 int err = 0;
549 i2eBordStrPtr pB = NULL;
550 int rc = -1;
551 const struct firmware *fw = NULL;
552 char *str;
553
554 str = cmd;
555
556 if (poll_only) {
557 /* Hard lock the interrupts to zero */
558 irq[0] = irq[1] = irq[2] = irq[3] = poll_only = 0;
559 }
560
561 /* Check module parameter with 'ip2=' has been passed or not */
562 if (!poll_only && (!strncmp(str, "ip2=", 4)))
563 ip2_setup(str);
564
565 ip2trace(ITRC_NO_PORT, ITRC_INIT, ITRC_ENTER, 0);
566
567 /* process command line arguments to modprobe or
568 insmod i.e. iop & irqp */
569 /* irqp and iop should ALWAYS be specified now... But we check
570 them individually just to be sure, anyways... */
571 for (i = 0; i < IP2_MAX_BOARDS; ++i) {
572 ip2config.addr[i] = io[i];
573 if (irq[i] >= 0)
574 ip2config.irq[i] = irq[i];
575 else
576 ip2config.irq[i] = 0;
577 /* This is a little bit of a hack. If poll_only=1 on command
578 line back in ip2.c OR all IRQs on all specified boards are
579 explicitly set to 0, then drop to poll only mode and override
580 PCI or EISA interrupts. This superceeds the old hack of
581 triggering if all interrupts were zero (like da default).
582 Still a hack but less prone to random acts of terrorism.
583
584 What we really should do, now that the IRQ default is set
585 to -1, is to use 0 as a hard coded, do not probe.
586
587 /\/\|=mhw=|\/\/
588 */
589 poll_only |= irq[i];
590 }
591 poll_only = !poll_only;
592
593 /* Announce our presence */
594 printk(KERN_INFO "%s version %s\n", pcName, pcVersion);
595
596 ip2_tty_driver = alloc_tty_driver(IP2_MAX_PORTS);
597 if (!ip2_tty_driver)
598 return -ENOMEM;
599
600 /* Initialise all the boards we can find (up to the maximum). */
601 for (i = 0; i < IP2_MAX_BOARDS; ++i) {
602 switch (ip2config.addr[i]) {
603 case 0: /* skip this slot even if card is present */
604 break;
605 default: /* ISA */
606 /* ISA address must be specified */
607 if (ip2config.addr[i] < 0x100 ||
608 ip2config.addr[i] > 0x3f8) {
609 printk(KERN_ERR "IP2: Bad ISA board %d "
610 "address %x\n", i,
611 ip2config.addr[i]);
612 ip2config.addr[i] = 0;
613 break;
614 }
615 ip2config.type[i] = ISA;
616
617 /* Check for valid irq argument, set for polling if
618 * invalid */
619 if (ip2config.irq[i] &&
620 !is_valid_irq(ip2config.irq[i])) {
621 printk(KERN_ERR "IP2: Bad IRQ(%d) specified\n",
622 ip2config.irq[i]);
623 /* 0 is polling and is valid in that sense */
624 ip2config.irq[i] = 0;
625 }
626 break;
627 case PCI:
628 #ifdef CONFIG_PCI
629 {
630 struct pci_dev *pdev = NULL;
631 u32 addr;
632 int status;
633
634 pdev = pci_get_device(PCI_VENDOR_ID_COMPUTONE,
635 PCI_DEVICE_ID_COMPUTONE_IP2EX, pdev);
636 if (pdev == NULL) {
637 ip2config.addr[i] = 0;
638 printk(KERN_ERR "IP2: PCI board %d not "
639 "found\n", i);
640 break;
641 }
642
643 if (pci_enable_device(pdev)) {
644 dev_err(&pdev->dev, "can't enable device\n");
645 goto out;
646 }
647 ip2config.type[i] = PCI;
648 ip2config.pci_dev[i] = pci_dev_get(pdev);
649 status = pci_read_config_dword(pdev, PCI_BASE_ADDRESS_1,
650 &addr);
651 if (addr & 1)
652 ip2config.addr[i] = (USHORT)(addr & 0xfffe);
653 else
654 dev_err(&pdev->dev, "I/O address error\n");
655
656 ip2config.irq[i] = pdev->irq;
657 out:
658 pci_dev_put(pdev);
659 }
660 #else
661 printk(KERN_ERR "IP2: PCI card specified but PCI "
662 "support not enabled.\n");
663 printk(KERN_ERR "IP2: Recompile kernel with CONFIG_PCI "
664 "defined!\n");
665 #endif /* CONFIG_PCI */
666 break;
667 case EISA:
668 ip2config.addr[i] = find_eisa_board(Eisa_slot + 1);
669 if (ip2config.addr[i] != 0) {
670 /* Eisa_irq set as side effect, boo */
671 ip2config.type[i] = EISA;
672 }
673 ip2config.irq[i] = Eisa_irq;
674 break;
675 } /* switch */
676 } /* for */
677
678 for (i = 0; i < IP2_MAX_BOARDS; ++i) {
679 if (ip2config.addr[i]) {
680 pB = kzalloc(sizeof(i2eBordStr), GFP_KERNEL);
681 if (pB) {
682 i2BoardPtrTable[i] = pB;
683 iiSetAddress(pB, ip2config.addr[i],
684 ii2DelayTimer);
685 iiReset(pB);
686 } else
687 printk(KERN_ERR "IP2: board memory allocation "
688 "error\n");
689 }
690 }
691 for (i = 0; i < IP2_MAX_BOARDS; ++i) {
692 pB = i2BoardPtrTable[i];
693 if (pB != NULL) {
694 iiResetDelay(pB);
695 break;
696 }
697 }
698 for (i = 0; i < IP2_MAX_BOARDS; ++i) {
699 /* We don't want to request the firmware unless we have at
700 least one board */
701 if (i2BoardPtrTable[i] != NULL) {
702 if (!fw)
703 fw = ip2_request_firmware();
704 if (!fw)
705 break;
706 ip2_init_board(i, fw);
707 }
708 }
709 if (fw)
710 release_firmware(fw);
711
712 ip2trace(ITRC_NO_PORT, ITRC_INIT, 2, 0);
713
714 ip2_tty_driver->owner = THIS_MODULE;
715 ip2_tty_driver->name = "ttyF";
716 ip2_tty_driver->driver_name = pcDriver_name;
717 ip2_tty_driver->major = IP2_TTY_MAJOR;
718 ip2_tty_driver->minor_start = 0;
719 ip2_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
720 ip2_tty_driver->subtype = SERIAL_TYPE_NORMAL;
721 ip2_tty_driver->init_termios = tty_std_termios;
722 ip2_tty_driver->init_termios.c_cflag = B9600|CS8|CREAD|HUPCL|CLOCAL;
723 ip2_tty_driver->flags = TTY_DRIVER_REAL_RAW |
724 TTY_DRIVER_DYNAMIC_DEV;
725 tty_set_operations(ip2_tty_driver, &ip2_ops);
726
727 ip2trace(ITRC_NO_PORT, ITRC_INIT, 3, 0);
728
729 err = tty_register_driver(ip2_tty_driver);
730 if (err) {
731 printk(KERN_ERR "IP2: failed to register tty driver\n");
732 put_tty_driver(ip2_tty_driver);
733 return err; /* leaking resources */
734 }
735
736 err = register_chrdev(IP2_IPL_MAJOR, pcIpl, &ip2_ipl);
737 if (err) {
738 printk(KERN_ERR "IP2: failed to register IPL device (%d)\n",
739 err);
740 } else {
741 /* create the sysfs class */
742 ip2_class = class_create(THIS_MODULE, "ip2");
743 if (IS_ERR(ip2_class)) {
744 err = PTR_ERR(ip2_class);
745 goto out_chrdev;
746 }
747 }
748 /* Register the read_procmem thing */
749 if (!proc_create("ip2mem",0,NULL,&ip2mem_proc_fops)) {
750 printk(KERN_ERR "IP2: failed to register read_procmem\n");
751 return -EIO; /* leaking resources */
752 }
753
754 ip2trace(ITRC_NO_PORT, ITRC_INIT, 4, 0);
755 /* Register the interrupt handler or poll handler, depending upon the
756 * specified interrupt.
757 */
758
759 for (i = 0; i < IP2_MAX_BOARDS; ++i) {
760 if (ip2config.addr[i] == 0)
761 continue;
762
763 pB = i2BoardPtrTable[i];
764 if (pB != NULL) {
765 device_create(ip2_class, NULL,
766 MKDEV(IP2_IPL_MAJOR, 4 * i),
767 NULL, "ipl%d", i);
768 device_create(ip2_class, NULL,
769 MKDEV(IP2_IPL_MAJOR, 4 * i + 1),
770 NULL, "stat%d", i);
771
772 for (box = 0; box < ABS_MAX_BOXES; box++)
773 for (j = 0; j < ABS_BIGGEST_BOX; j++)
774 if (pB->i2eChannelMap[box] & (1 << j))
775 tty_register_device(
776 ip2_tty_driver,
777 j + ABS_BIGGEST_BOX *
778 (box+i*ABS_MAX_BOXES),
779 NULL);
780 }
781
782 if (poll_only) {
783 /* Poll only forces driver to only use polling and
784 to ignore the probed PCI or EISA interrupts. */
785 ip2config.irq[i] = CIR_POLL;
786 }
787 if (ip2config.irq[i] == CIR_POLL) {
788 retry:
789 if (!timer_pending(&PollTimer)) {
790 mod_timer(&PollTimer, POLL_TIMEOUT);
791 printk(KERN_INFO "IP2: polling\n");
792 }
793 } else {
794 if (have_requested_irq(ip2config.irq[i]))
795 continue;
796 rc = request_irq(ip2config.irq[i], ip2_interrupt,
797 IP2_SA_FLAGS |
798 (ip2config.type[i] == PCI ? IRQF_SHARED : 0),
799 pcName, i2BoardPtrTable[i]);
800 if (rc) {
801 printk(KERN_ERR "IP2: request_irq failed: "
802 "error %d\n", rc);
803 ip2config.irq[i] = CIR_POLL;
804 printk(KERN_INFO "IP2: Polling %ld/sec.\n",
805 (POLL_TIMEOUT - jiffies));
806 goto retry;
807 }
808 mark_requested_irq(ip2config.irq[i]);
809 /* Initialise the interrupt handler bottom half
810 * (aka slih). */
811 }
812 }
813
814 for (i = 0; i < IP2_MAX_BOARDS; ++i) {
815 if (i2BoardPtrTable[i]) {
816 /* set and enable board interrupt */
817 set_irq(i, ip2config.irq[i]);
818 }
819 }
820
821 ip2trace(ITRC_NO_PORT, ITRC_INIT, ITRC_RETURN, 0);
822
823 return 0;
824
825 out_chrdev:
826 unregister_chrdev(IP2_IPL_MAJOR, "ip2");
827 /* unregister and put tty here */
828 return err;
829 }
830 module_init(ip2_loadmain);
831
832 /******************************************************************************/
833 /* Function: ip2_init_board() */
834 /* Parameters: Index of board in configuration structure */
835 /* Returns: Success (0) */
836 /* */
837 /* Description: */
838 /* This function initializes the specified board. The loadware is copied to */
839 /* the board, the channel structures are initialized, and the board details */
840 /* are reported on the console. */
841 /******************************************************************************/
842 static void
843 ip2_init_board(int boardnum, const struct firmware *fw)
844 {
845 int i;
846 int nports = 0, nboxes = 0;
847 i2ChanStrPtr pCh;
848 i2eBordStrPtr pB = i2BoardPtrTable[boardnum];
849
850 if ( !iiInitialize ( pB ) ) {
851 printk ( KERN_ERR "IP2: Failed to initialize board at 0x%x, error %d\n",
852 pB->i2eBase, pB->i2eError );
853 goto err_initialize;
854 }
855 printk(KERN_INFO "IP2: Board %d: addr=0x%x irq=%d\n", boardnum + 1,
856 ip2config.addr[boardnum], ip2config.irq[boardnum] );
857
858 if (!request_region( ip2config.addr[boardnum], 8, pcName )) {
859 printk(KERN_ERR "IP2: bad addr=0x%x\n", ip2config.addr[boardnum]);
860 goto err_initialize;
861 }
862
863 if ( iiDownloadAll ( pB, (loadHdrStrPtr)fw->data, 1, fw->size )
864 != II_DOWN_GOOD ) {
865 printk ( KERN_ERR "IP2: failed to download loadware\n" );
866 goto err_release_region;
867 } else {
868 printk ( KERN_INFO "IP2: fv=%d.%d.%d lv=%d.%d.%d\n",
869 pB->i2ePom.e.porVersion,
870 pB->i2ePom.e.porRevision,
871 pB->i2ePom.e.porSubRev, pB->i2eLVersion,
872 pB->i2eLRevision, pB->i2eLSub );
873 }
874
875 switch ( pB->i2ePom.e.porID & ~POR_ID_RESERVED ) {
876
877 default:
878 printk( KERN_ERR "IP2: Unknown board type, ID = %x\n",
879 pB->i2ePom.e.porID );
880 nports = 0;
881 goto err_release_region;
882 break;
883
884 case POR_ID_II_4: /* IntelliPort-II, ISA-4 (4xRJ45) */
885 printk ( KERN_INFO "IP2: ISA-4\n" );
886 nports = 4;
887 break;
888
889 case POR_ID_II_8: /* IntelliPort-II, 8-port using standard brick. */
890 printk ( KERN_INFO "IP2: ISA-8 std\n" );
891 nports = 8;
892 break;
893
894 case POR_ID_II_8R: /* IntelliPort-II, 8-port using RJ11's (no CTS) */
895 printk ( KERN_INFO "IP2: ISA-8 RJ11\n" );
896 nports = 8;
897 break;
898
899 case POR_ID_FIIEX: /* IntelliPort IIEX */
900 {
901 int portnum = IP2_PORTS_PER_BOARD * boardnum;
902 int box;
903
904 for( box = 0; box < ABS_MAX_BOXES; ++box ) {
905 if ( pB->i2eChannelMap[box] != 0 ) {
906 ++nboxes;
907 }
908 for( i = 0; i < ABS_BIGGEST_BOX; ++i ) {
909 if ( pB->i2eChannelMap[box] & 1<< i ) {
910 ++nports;
911 }
912 }
913 }
914 DevTableMem[boardnum] = pCh =
915 kmalloc( sizeof(i2ChanStr) * nports, GFP_KERNEL );
916 if ( !pCh ) {
917 printk ( KERN_ERR "IP2: (i2_init_channel:) Out of memory.\n");
918 goto err_release_region;
919 }
920 if ( !i2InitChannels( pB, nports, pCh ) ) {
921 printk(KERN_ERR "IP2: i2InitChannels failed: %d\n",pB->i2eError);
922 kfree ( pCh );
923 goto err_release_region;
924 }
925 pB->i2eChannelPtr = &DevTable[portnum];
926 pB->i2eChannelCnt = ABS_MOST_PORTS;
927
928 for( box = 0; box < ABS_MAX_BOXES; ++box, portnum += ABS_BIGGEST_BOX ) {
929 for( i = 0; i < ABS_BIGGEST_BOX; ++i ) {
930 if ( pB->i2eChannelMap[box] & (1 << i) ) {
931 DevTable[portnum + i] = pCh;
932 pCh->port_index = portnum + i;
933 pCh++;
934 }
935 }
936 }
937 printk(KERN_INFO "IP2: EX box=%d ports=%d %d bit\n",
938 nboxes, nports, pB->i2eDataWidth16 ? 16 : 8 );
939 }
940 goto ex_exit;
941 }
942 DevTableMem[boardnum] = pCh =
943 kmalloc ( sizeof (i2ChanStr) * nports, GFP_KERNEL );
944 if ( !pCh ) {
945 printk ( KERN_ERR "IP2: (i2_init_channel:) Out of memory.\n");
946 goto err_release_region;
947 }
948 pB->i2eChannelPtr = pCh;
949 pB->i2eChannelCnt = nports;
950 if ( !i2InitChannels( pB, nports, pCh ) ) {
951 printk(KERN_ERR "IP2: i2InitChannels failed: %d\n",pB->i2eError);
952 kfree ( pCh );
953 goto err_release_region;
954 }
955 pB->i2eChannelPtr = &DevTable[IP2_PORTS_PER_BOARD * boardnum];
956
957 for( i = 0; i < pB->i2eChannelCnt; ++i ) {
958 DevTable[IP2_PORTS_PER_BOARD * boardnum + i] = pCh;
959 pCh->port_index = (IP2_PORTS_PER_BOARD * boardnum) + i;
960 pCh++;
961 }
962 ex_exit:
963 INIT_WORK(&pB->tqueue_interrupt, ip2_interrupt_bh);
964 return;
965
966 err_release_region:
967 release_region(ip2config.addr[boardnum], 8);
968 err_initialize:
969 kfree ( pB );
970 i2BoardPtrTable[boardnum] = NULL;
971 return;
972 }
973
974 /******************************************************************************/
975 /* Function: find_eisa_board ( int start_slot ) */
976 /* Parameters: First slot to check */
977 /* Returns: Address of EISA IntelliPort II controller */
978 /* */
979 /* Description: */
980 /* This function searches for an EISA IntelliPort controller, starting */
981 /* from the specified slot number. If the motherboard is not identified as an */
982 /* EISA motherboard, or no valid board ID is selected it returns 0. Otherwise */
983 /* it returns the base address of the controller. */
984 /******************************************************************************/
985 static unsigned short
986 find_eisa_board( int start_slot )
987 {
988 int i, j;
989 unsigned int idm = 0;
990 unsigned int idp = 0;
991 unsigned int base = 0;
992 unsigned int value;
993 int setup_address;
994 int setup_irq;
995 int ismine = 0;
996
997 /*
998 * First a check for an EISA motherboard, which we do by comparing the
999 * EISA ID registers for the system board and the first couple of slots.
1000 * No slot ID should match the system board ID, but on an ISA or PCI
1001 * machine the odds are that an empty bus will return similar values for
1002 * each slot.
1003 */
1004 i = 0x0c80;
1005 value = (inb(i) << 24) + (inb(i+1) << 16) + (inb(i+2) << 8) + inb(i+3);
1006 for( i = 0x1c80; i <= 0x4c80; i += 0x1000 ) {
1007 j = (inb(i)<<24)+(inb(i+1)<<16)+(inb(i+2)<<8)+inb(i+3);
1008 if ( value == j )
1009 return 0;
1010 }
1011
1012 /*
1013 * OK, so we are inclined to believe that this is an EISA machine. Find
1014 * an IntelliPort controller.
1015 */
1016 for( i = start_slot; i < 16; i++ ) {
1017 base = i << 12;
1018 idm = (inb(base + 0xc80) << 8) | (inb(base + 0xc81) & 0xff);
1019 idp = (inb(base + 0xc82) << 8) | (inb(base + 0xc83) & 0xff);
1020 ismine = 0;
1021 if ( idm == 0x0e8e ) {
1022 if ( idp == 0x0281 || idp == 0x0218 ) {
1023 ismine = 1;
1024 } else if ( idp == 0x0282 || idp == 0x0283 ) {
1025 ismine = 3; /* Can do edge-trigger */
1026 }
1027 if ( ismine ) {
1028 Eisa_slot = i;
1029 break;
1030 }
1031 }
1032 }
1033 if ( !ismine )
1034 return 0;
1035
1036 /* It's some sort of EISA card, but at what address is it configured? */
1037
1038 setup_address = base + 0xc88;
1039 value = inb(base + 0xc86);
1040 setup_irq = (value & 8) ? Valid_Irqs[value & 7] : 0;
1041
1042 if ( (ismine & 2) && !(value & 0x10) ) {
1043 ismine = 1; /* Could be edging, but not */
1044 }
1045
1046 if ( Eisa_irq == 0 ) {
1047 Eisa_irq = setup_irq;
1048 } else if ( Eisa_irq != setup_irq ) {
1049 printk ( KERN_ERR "IP2: EISA irq mismatch between EISA controllers\n" );
1050 }
1051
1052 #ifdef IP2DEBUG_INIT
1053 printk(KERN_DEBUG "Computone EISA board in slot %d, I.D. 0x%x%x, Address 0x%x",
1054 base >> 12, idm, idp, setup_address);
1055 if ( Eisa_irq ) {
1056 printk(KERN_DEBUG ", Interrupt %d %s\n",
1057 setup_irq, (ismine & 2) ? "(edge)" : "(level)");
1058 } else {
1059 printk(KERN_DEBUG ", (polled)\n");
1060 }
1061 #endif
1062 return setup_address;
1063 }
1064
1065 /******************************************************************************/
1066 /* Function: set_irq() */
1067 /* Parameters: index to board in board table */
1068 /* IRQ to use */
1069 /* Returns: Success (0) */
1070 /* */
1071 /* Description: */
1072 /******************************************************************************/
1073 static void
1074 set_irq( int boardnum, int boardIrq )
1075 {
1076 unsigned char tempCommand[16];
1077 i2eBordStrPtr pB = i2BoardPtrTable[boardnum];
1078 unsigned long flags;
1079
1080 /*
1081 * Notify the boards they may generate interrupts. This is done by
1082 * sending an in-line command to channel 0 on each board. This is why
1083 * the channels have to be defined already. For each board, if the
1084 * interrupt has never been defined, we must do so NOW, directly, since
1085 * board will not send flow control or even give an interrupt until this
1086 * is done. If polling we must send 0 as the interrupt parameter.
1087 */
1088
1089 // We will get an interrupt here at the end of this function
1090
1091 iiDisableMailIrq(pB);
1092
1093 /* We build up the entire packet header. */
1094 CHANNEL_OF(tempCommand) = 0;
1095 PTYPE_OF(tempCommand) = PTYPE_INLINE;
1096 CMD_COUNT_OF(tempCommand) = 2;
1097 (CMD_OF(tempCommand))[0] = CMDVALUE_IRQ;
1098 (CMD_OF(tempCommand))[1] = boardIrq;
1099 /*
1100 * Write to FIFO; don't bother to adjust fifo capacity for this, since
1101 * board will respond almost immediately after SendMail hit.
1102 */
1103 write_lock_irqsave(&pB->write_fifo_spinlock, flags);
1104 iiWriteBuf(pB, tempCommand, 4);
1105 write_unlock_irqrestore(&pB->write_fifo_spinlock, flags);
1106 pB->i2eUsingIrq = boardIrq;
1107 pB->i2eOutMailWaiting |= MB_OUT_STUFFED;
1108
1109 /* Need to update number of boards before you enable mailbox int */
1110 ++i2nBoards;
1111
1112 CHANNEL_OF(tempCommand) = 0;
1113 PTYPE_OF(tempCommand) = PTYPE_BYPASS;
1114 CMD_COUNT_OF(tempCommand) = 6;
1115 (CMD_OF(tempCommand))[0] = 88; // SILO
1116 (CMD_OF(tempCommand))[1] = 64; // chars
1117 (CMD_OF(tempCommand))[2] = 32; // ms
1118
1119 (CMD_OF(tempCommand))[3] = 28; // MAX_BLOCK
1120 (CMD_OF(tempCommand))[4] = 64; // chars
1121
1122 (CMD_OF(tempCommand))[5] = 87; // HW_TEST
1123 write_lock_irqsave(&pB->write_fifo_spinlock, flags);
1124 iiWriteBuf(pB, tempCommand, 8);
1125 write_unlock_irqrestore(&pB->write_fifo_spinlock, flags);
1126
1127 CHANNEL_OF(tempCommand) = 0;
1128 PTYPE_OF(tempCommand) = PTYPE_BYPASS;
1129 CMD_COUNT_OF(tempCommand) = 1;
1130 (CMD_OF(tempCommand))[0] = 84; /* get BOX_IDS */
1131 iiWriteBuf(pB, tempCommand, 3);
1132
1133 #ifdef XXX
1134 // enable heartbeat for test porpoises
1135 CHANNEL_OF(tempCommand) = 0;
1136 PTYPE_OF(tempCommand) = PTYPE_BYPASS;
1137 CMD_COUNT_OF(tempCommand) = 2;
1138 (CMD_OF(tempCommand))[0] = 44; /* get ping */
1139 (CMD_OF(tempCommand))[1] = 200; /* 200 ms */
1140 write_lock_irqsave(&pB->write_fifo_spinlock, flags);
1141 iiWriteBuf(pB, tempCommand, 4);
1142 write_unlock_irqrestore(&pB->write_fifo_spinlock, flags);
1143 #endif
1144
1145 iiEnableMailIrq(pB);
1146 iiSendPendingMail(pB);
1147 }
1148
1149 /******************************************************************************/
1150 /* Interrupt Handler Section */
1151 /******************************************************************************/
1152
1153 static inline void
1154 service_all_boards(void)
1155 {
1156 int i;
1157 i2eBordStrPtr pB;
1158
1159 /* Service every board on the list */
1160 for( i = 0; i < IP2_MAX_BOARDS; ++i ) {
1161 pB = i2BoardPtrTable[i];
1162 if ( pB ) {
1163 i2ServiceBoard( pB );
1164 }
1165 }
1166 }
1167
1168
1169 /******************************************************************************/
1170 /* Function: ip2_interrupt_bh(work) */
1171 /* Parameters: work - pointer to the board structure */
1172 /* Returns: Nothing */
1173 /* */
1174 /* Description: */
1175 /* Service the board in a bottom half interrupt handler and then */
1176 /* reenable the board's interrupts if it has an IRQ number */
1177 /* */
1178 /******************************************************************************/
1179 static void
1180 ip2_interrupt_bh(struct work_struct *work)
1181 {
1182 i2eBordStrPtr pB = container_of(work, i2eBordStr, tqueue_interrupt);
1183 // pB better well be set or we have a problem! We can only get
1184 // here from the IMMEDIATE queue. Here, we process the boards.
1185 // Checking pB doesn't cost much and it saves us from the sanity checkers.
1186
1187 bh_counter++;
1188
1189 if ( pB ) {
1190 i2ServiceBoard( pB );
1191 if( pB->i2eUsingIrq ) {
1192 // Re-enable his interrupts
1193 iiEnableMailIrq(pB);
1194 }
1195 }
1196 }
1197
1198
1199 /******************************************************************************/
1200 /* Function: ip2_interrupt(int irq, void *dev_id) */
1201 /* Parameters: irq - interrupt number */
1202 /* pointer to optional device ID structure */
1203 /* Returns: Nothing */
1204 /* */
1205 /* Description: */
1206 /* */
1207 /* Our task here is simply to identify each board which needs servicing. */
1208 /* If we are queuing then, queue it to be serviced, and disable its irq */
1209 /* mask otherwise process the board directly. */
1210 /* */
1211 /* We could queue by IRQ but that just complicates things on both ends */
1212 /* with very little gain in performance (how many instructions does */
1213 /* it take to iterate on the immediate queue). */
1214 /* */
1215 /* */
1216 /******************************************************************************/
1217 static void
1218 ip2_irq_work(i2eBordStrPtr pB)
1219 {
1220 #ifdef USE_IQI
1221 if (NO_MAIL_HERE != ( pB->i2eStartMail = iiGetMail(pB))) {
1222 // Disable his interrupt (will be enabled when serviced)
1223 // This is mostly to protect from reentrancy.
1224 iiDisableMailIrq(pB);
1225
1226 // Park the board on the immediate queue for processing.
1227 schedule_work(&pB->tqueue_interrupt);
1228
1229 // Make sure the immediate queue is flagged to fire.
1230 }
1231 #else
1232
1233 // We are using immediate servicing here. This sucks and can
1234 // cause all sorts of havoc with ppp and others. The failsafe
1235 // check on iiSendPendingMail could also throw a hairball.
1236
1237 i2ServiceBoard( pB );
1238
1239 #endif /* USE_IQI */
1240 }
1241
1242 static void
1243 ip2_polled_interrupt(void)
1244 {
1245 int i;
1246 i2eBordStrPtr pB;
1247
1248 ip2trace(ITRC_NO_PORT, ITRC_INTR, 99, 1, 0);
1249
1250 /* Service just the boards on the list using this irq */
1251 for( i = 0; i < i2nBoards; ++i ) {
1252 pB = i2BoardPtrTable[i];
1253
1254 // Only process those boards which match our IRQ.
1255 // IRQ = 0 for polled boards, we won't poll "IRQ" boards
1256
1257 if (pB && pB->i2eUsingIrq == 0)
1258 ip2_irq_work(pB);
1259 }
1260
1261 ++irq_counter;
1262
1263 ip2trace (ITRC_NO_PORT, ITRC_INTR, ITRC_RETURN, 0 );
1264 }
1265
1266 static irqreturn_t
1267 ip2_interrupt(int irq, void *dev_id)
1268 {
1269 i2eBordStrPtr pB = dev_id;
1270
1271 ip2trace (ITRC_NO_PORT, ITRC_INTR, 99, 1, pB->i2eUsingIrq );
1272
1273 ip2_irq_work(pB);
1274
1275 ++irq_counter;
1276
1277 ip2trace (ITRC_NO_PORT, ITRC_INTR, ITRC_RETURN, 0 );
1278 return IRQ_HANDLED;
1279 }
1280
1281 /******************************************************************************/
1282 /* Function: ip2_poll(unsigned long arg) */
1283 /* Parameters: ? */
1284 /* Returns: Nothing */
1285 /* */
1286 /* Description: */
1287 /* This function calls the library routine i2ServiceBoard for each board in */
1288 /* the board table. This is used instead of the interrupt routine when polled */
1289 /* mode is specified. */
1290 /******************************************************************************/
1291 static void
1292 ip2_poll(unsigned long arg)
1293 {
1294 ip2trace (ITRC_NO_PORT, ITRC_INTR, 100, 0 );
1295
1296 // Just polled boards, IRQ = 0 will hit all non-interrupt boards.
1297 // It will NOT poll boards handled by hard interrupts.
1298 // The issue of queued BH interrupts is handled in ip2_interrupt().
1299 ip2_polled_interrupt();
1300
1301 mod_timer(&PollTimer, POLL_TIMEOUT);
1302
1303 ip2trace (ITRC_NO_PORT, ITRC_INTR, ITRC_RETURN, 0 );
1304 }
1305
1306 static void do_input(struct work_struct *work)
1307 {
1308 i2ChanStrPtr pCh = container_of(work, i2ChanStr, tqueue_input);
1309 unsigned long flags;
1310
1311 ip2trace(CHANN, ITRC_INPUT, 21, 0 );
1312
1313 // Data input
1314 if ( pCh->pTTY != NULL ) {
1315 read_lock_irqsave(&pCh->Ibuf_spinlock, flags);
1316 if (!pCh->throttled && (pCh->Ibuf_stuff != pCh->Ibuf_strip)) {
1317 read_unlock_irqrestore(&pCh->Ibuf_spinlock, flags);
1318 i2Input( pCh );
1319 } else
1320 read_unlock_irqrestore(&pCh->Ibuf_spinlock, flags);
1321 } else {
1322 ip2trace(CHANN, ITRC_INPUT, 22, 0 );
1323
1324 i2InputFlush( pCh );
1325 }
1326 }
1327
1328 // code duplicated from n_tty (ldisc)
1329 static inline void isig(int sig, struct tty_struct *tty, int flush)
1330 {
1331 /* FIXME: This is completely bogus */
1332 if (tty->pgrp)
1333 kill_pgrp(tty->pgrp, sig, 1);
1334 if (flush || !L_NOFLSH(tty)) {
1335 if ( tty->ldisc->ops->flush_buffer )
1336 tty->ldisc->ops->flush_buffer(tty);
1337 i2InputFlush( tty->driver_data );
1338 }
1339 }
1340
1341 static void do_status(struct work_struct *work)
1342 {
1343 i2ChanStrPtr pCh = container_of(work, i2ChanStr, tqueue_status);
1344 int status;
1345
1346 status = i2GetStatus( pCh, (I2_BRK|I2_PAR|I2_FRA|I2_OVR) );
1347
1348 ip2trace (CHANN, ITRC_STATUS, 21, 1, status );
1349
1350 if (pCh->pTTY && (status & (I2_BRK|I2_PAR|I2_FRA|I2_OVR)) ) {
1351 if ( (status & I2_BRK) ) {
1352 // code duplicated from n_tty (ldisc)
1353 if (I_IGNBRK(pCh->pTTY))
1354 goto skip_this;
1355 if (I_BRKINT(pCh->pTTY)) {
1356 isig(SIGINT, pCh->pTTY, 1);
1357 goto skip_this;
1358 }
1359 wake_up_interruptible(&pCh->pTTY->read_wait);
1360 }
1361 #ifdef NEVER_HAPPENS_AS_SETUP_XXX
1362 // and can't work because we don't know the_char
1363 // as the_char is reported on a separate path
1364 // The intelligent board does this stuff as setup
1365 {
1366 char brkf = TTY_NORMAL;
1367 unsigned char brkc = '\0';
1368 unsigned char tmp;
1369 if ( (status & I2_BRK) ) {
1370 brkf = TTY_BREAK;
1371 brkc = '\0';
1372 }
1373 else if (status & I2_PAR) {
1374 brkf = TTY_PARITY;
1375 brkc = the_char;
1376 } else if (status & I2_FRA) {
1377 brkf = TTY_FRAME;
1378 brkc = the_char;
1379 } else if (status & I2_OVR) {
1380 brkf = TTY_OVERRUN;
1381 brkc = the_char;
1382 }
1383 tmp = pCh->pTTY->real_raw;
1384 pCh->pTTY->real_raw = 0;
1385 pCh->pTTY->ldisc->ops.receive_buf( pCh->pTTY, &brkc, &brkf, 1 );
1386 pCh->pTTY->real_raw = tmp;
1387 }
1388 #endif /* NEVER_HAPPENS_AS_SETUP_XXX */
1389 }
1390 skip_this:
1391
1392 if ( status & (I2_DDCD | I2_DDSR | I2_DCTS | I2_DRI) ) {
1393 wake_up_interruptible(&pCh->delta_msr_wait);
1394
1395 if ( (pCh->flags & ASYNC_CHECK_CD) && (status & I2_DDCD) ) {
1396 if ( status & I2_DCD ) {
1397 if ( pCh->wopen ) {
1398 wake_up_interruptible ( &pCh->open_wait );
1399 }
1400 } else {
1401 if (pCh->pTTY && (!(pCh->pTTY->termios->c_cflag & CLOCAL)) ) {
1402 tty_hangup( pCh->pTTY );
1403 }
1404 }
1405 }
1406 }
1407
1408 ip2trace (CHANN, ITRC_STATUS, 26, 0 );
1409 }
1410
1411 /******************************************************************************/
1412 /* Device Open/Close/Ioctl Entry Point Section */
1413 /******************************************************************************/
1414
1415 /******************************************************************************/
1416 /* Function: open_sanity_check() */
1417 /* Parameters: Pointer to tty structure */
1418 /* Pointer to file structure */
1419 /* Returns: Success or failure */
1420 /* */
1421 /* Description: */
1422 /* Verifies the structure magic numbers and cross links. */
1423 /******************************************************************************/
1424 #ifdef IP2DEBUG_OPEN
1425 static void
1426 open_sanity_check( i2ChanStrPtr pCh, i2eBordStrPtr pBrd )
1427 {
1428 if ( pBrd->i2eValid != I2E_MAGIC ) {
1429 printk(KERN_ERR "IP2: invalid board structure\n" );
1430 } else if ( pBrd != pCh->pMyBord ) {
1431 printk(KERN_ERR "IP2: board structure pointer mismatch (%p)\n",
1432 pCh->pMyBord );
1433 } else if ( pBrd->i2eChannelCnt < pCh->port_index ) {
1434 printk(KERN_ERR "IP2: bad device index (%d)\n", pCh->port_index );
1435 } else if (&((i2ChanStrPtr)pBrd->i2eChannelPtr)[pCh->port_index] != pCh) {
1436 } else {
1437 printk(KERN_INFO "IP2: all pointers check out!\n" );
1438 }
1439 }
1440 #endif
1441
1442
1443 /******************************************************************************/
1444 /* Function: ip2_open() */
1445 /* Parameters: Pointer to tty structure */
1446 /* Pointer to file structure */
1447 /* Returns: Success or failure */
1448 /* */
1449 /* Description: (MANDATORY) */
1450 /* A successful device open has to run a gauntlet of checks before it */
1451 /* completes. After some sanity checking and pointer setup, the function */
1452 /* blocks until all conditions are satisfied. It then initialises the port to */
1453 /* the default characteristics and returns. */
1454 /******************************************************************************/
1455 static int
1456 ip2_open( PTTY tty, struct file *pFile )
1457 {
1458 wait_queue_t wait;
1459 int rc = 0;
1460 int do_clocal = 0;
1461 i2ChanStrPtr pCh = DevTable[tty->index];
1462
1463 ip2trace (tty->index, ITRC_OPEN, ITRC_ENTER, 0 );
1464
1465 if ( pCh == NULL ) {
1466 return -ENODEV;
1467 }
1468 /* Setup pointer links in device and tty structures */
1469 pCh->pTTY = tty;
1470 tty->driver_data = pCh;
1471
1472 #ifdef IP2DEBUG_OPEN
1473 printk(KERN_DEBUG \
1474 "IP2:open(tty=%p,pFile=%p):dev=%s,ch=%d,idx=%d\n",
1475 tty, pFile, tty->name, pCh->infl.hd.i2sChannel, pCh->port_index);
1476 open_sanity_check ( pCh, pCh->pMyBord );
1477 #endif
1478
1479 i2QueueCommands(PTYPE_INLINE, pCh, 100, 3, CMD_DTRUP,CMD_RTSUP,CMD_DCD_REP);
1480 pCh->dataSetOut |= (I2_DTR | I2_RTS);
1481 serviceOutgoingFifo( pCh->pMyBord );
1482
1483 /* Block here until the port is ready (per serial and istallion) */
1484 /*
1485 * 1. If the port is in the middle of closing wait for the completion
1486 * and then return the appropriate error.
1487 */
1488 init_waitqueue_entry(&wait, current);
1489 add_wait_queue(&pCh->close_wait, &wait);
1490 set_current_state( TASK_INTERRUPTIBLE );
1491
1492 if ( tty_hung_up_p(pFile) || ( pCh->flags & ASYNC_CLOSING )) {
1493 if ( pCh->flags & ASYNC_CLOSING ) {
1494 tty_unlock();
1495 schedule();
1496 tty_lock();
1497 }
1498 if ( tty_hung_up_p(pFile) ) {
1499 set_current_state( TASK_RUNNING );
1500 remove_wait_queue(&pCh->close_wait, &wait);
1501 return( pCh->flags & ASYNC_HUP_NOTIFY ) ? -EAGAIN : -ERESTARTSYS;
1502 }
1503 }
1504 set_current_state( TASK_RUNNING );
1505 remove_wait_queue(&pCh->close_wait, &wait);
1506
1507 /*
1508 * 3. Handle a non-blocking open of a normal port.
1509 */
1510 if ( (pFile->f_flags & O_NONBLOCK) || (tty->flags & (1<<TTY_IO_ERROR) )) {
1511 pCh->flags |= ASYNC_NORMAL_ACTIVE;
1512 goto noblock;
1513 }
1514 /*
1515 * 4. Now loop waiting for the port to be free and carrier present
1516 * (if required).
1517 */
1518 if ( tty->termios->c_cflag & CLOCAL )
1519 do_clocal = 1;
1520
1521 #ifdef IP2DEBUG_OPEN
1522 printk(KERN_DEBUG "OpenBlock: do_clocal = %d\n", do_clocal);
1523 #endif
1524
1525 ++pCh->wopen;
1526
1527 init_waitqueue_entry(&wait, current);
1528 add_wait_queue(&pCh->open_wait, &wait);
1529
1530 for(;;) {
1531 i2QueueCommands(PTYPE_INLINE, pCh, 100, 2, CMD_DTRUP, CMD_RTSUP);
1532 pCh->dataSetOut |= (I2_DTR | I2_RTS);
1533 set_current_state( TASK_INTERRUPTIBLE );
1534 serviceOutgoingFifo( pCh->pMyBord );
1535 if ( tty_hung_up_p(pFile) ) {
1536 set_current_state( TASK_RUNNING );
1537 remove_wait_queue(&pCh->open_wait, &wait);
1538 return ( pCh->flags & ASYNC_HUP_NOTIFY ) ? -EBUSY : -ERESTARTSYS;
1539 }
1540 if (!(pCh->flags & ASYNC_CLOSING) &&
1541 (do_clocal || (pCh->dataSetIn & I2_DCD) )) {
1542 rc = 0;
1543 break;
1544 }
1545
1546 #ifdef IP2DEBUG_OPEN
1547 printk(KERN_DEBUG "ASYNC_CLOSING = %s\n",
1548 (pCh->flags & ASYNC_CLOSING)?"True":"False");
1549 printk(KERN_DEBUG "OpenBlock: waiting for CD or signal\n");
1550 #endif
1551 ip2trace (CHANN, ITRC_OPEN, 3, 2, 0,
1552 (pCh->flags & ASYNC_CLOSING) );
1553 /* check for signal */
1554 if (signal_pending(current)) {
1555 rc = (( pCh->flags & ASYNC_HUP_NOTIFY ) ? -EAGAIN : -ERESTARTSYS);
1556 break;
1557 }
1558 tty_unlock();
1559 schedule();
1560 tty_lock();
1561 }
1562 set_current_state( TASK_RUNNING );
1563 remove_wait_queue(&pCh->open_wait, &wait);
1564
1565 --pCh->wopen; //why count?
1566
1567 ip2trace (CHANN, ITRC_OPEN, 4, 0 );
1568
1569 if (rc != 0 ) {
1570 return rc;
1571 }
1572 pCh->flags |= ASYNC_NORMAL_ACTIVE;
1573
1574 noblock:
1575
1576 /* first open - Assign termios structure to port */
1577 if ( tty->count == 1 ) {
1578 i2QueueCommands(PTYPE_INLINE, pCh, 0, 2, CMD_CTSFL_DSAB, CMD_RTSFL_DSAB);
1579 /* Now we must send the termios settings to the loadware */
1580 set_params( pCh, NULL );
1581 }
1582
1583 /*
1584 * Now set any i2lib options. These may go away if the i2lib code ends
1585 * up rolled into the mainline.
1586 */
1587 pCh->channelOptions |= CO_NBLOCK_WRITE;
1588
1589 #ifdef IP2DEBUG_OPEN
1590 printk (KERN_DEBUG "IP2: open completed\n" );
1591 #endif
1592 serviceOutgoingFifo( pCh->pMyBord );
1593
1594 ip2trace (CHANN, ITRC_OPEN, ITRC_RETURN, 0 );
1595
1596 return 0;
1597 }
1598
1599 /******************************************************************************/
1600 /* Function: ip2_close() */
1601 /* Parameters: Pointer to tty structure */
1602 /* Pointer to file structure */
1603 /* Returns: Nothing */
1604 /* */
1605 /* Description: */
1606 /* */
1607 /* */
1608 /******************************************************************************/
1609 static void
1610 ip2_close( PTTY tty, struct file *pFile )
1611 {
1612 i2ChanStrPtr pCh = tty->driver_data;
1613
1614 if ( !pCh ) {
1615 return;
1616 }
1617
1618 ip2trace (CHANN, ITRC_CLOSE, ITRC_ENTER, 0 );
1619
1620 #ifdef IP2DEBUG_OPEN
1621 printk(KERN_DEBUG "IP2:close %s:\n",tty->name);
1622 #endif
1623
1624 if ( tty_hung_up_p ( pFile ) ) {
1625
1626 ip2trace (CHANN, ITRC_CLOSE, 2, 1, 2 );
1627
1628 return;
1629 }
1630 if ( tty->count > 1 ) { /* not the last close */
1631
1632 ip2trace (CHANN, ITRC_CLOSE, 2, 1, 3 );
1633
1634 return;
1635 }
1636 pCh->flags |= ASYNC_CLOSING; // last close actually
1637
1638 tty->closing = 1;
1639
1640 if (pCh->ClosingWaitTime != ASYNC_CLOSING_WAIT_NONE) {
1641 /*
1642 * Before we drop DTR, make sure the transmitter has completely drained.
1643 * This uses an timeout, after which the close
1644 * completes.
1645 */
1646 ip2_wait_until_sent(tty, pCh->ClosingWaitTime );
1647 }
1648 /*
1649 * At this point we stop accepting input. Here we flush the channel
1650 * input buffer which will allow the board to send up more data. Any
1651 * additional input is tossed at interrupt/poll time.
1652 */
1653 i2InputFlush( pCh );
1654
1655 /* disable DSS reporting */
1656 i2QueueCommands(PTYPE_INLINE, pCh, 100, 4,
1657 CMD_DCD_NREP, CMD_CTS_NREP, CMD_DSR_NREP, CMD_RI_NREP);
1658 if (tty->termios->c_cflag & HUPCL) {
1659 i2QueueCommands(PTYPE_INLINE, pCh, 100, 2, CMD_RTSDN, CMD_DTRDN);
1660 pCh->dataSetOut &= ~(I2_DTR | I2_RTS);
1661 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_PAUSE(25));
1662 }
1663
1664 serviceOutgoingFifo ( pCh->pMyBord );
1665
1666 tty_ldisc_flush(tty);
1667 tty_driver_flush_buffer(tty);
1668 tty->closing = 0;
1669
1670 pCh->pTTY = NULL;
1671
1672 if (pCh->wopen) {
1673 if (pCh->ClosingDelay) {
1674 msleep_interruptible(jiffies_to_msecs(pCh->ClosingDelay));
1675 }
1676 wake_up_interruptible(&pCh->open_wait);
1677 }
1678
1679 pCh->flags &=~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
1680 wake_up_interruptible(&pCh->close_wait);
1681
1682 #ifdef IP2DEBUG_OPEN
1683 DBG_CNT("ip2_close: after wakeups--");
1684 #endif
1685
1686
1687 ip2trace (CHANN, ITRC_CLOSE, ITRC_RETURN, 1, 1 );
1688
1689 return;
1690 }
1691
1692 /******************************************************************************/
1693 /* Function: ip2_hangup() */
1694 /* Parameters: Pointer to tty structure */
1695 /* Returns: Nothing */
1696 /* */
1697 /* Description: */
1698 /* */
1699 /* */
1700 /******************************************************************************/
1701 static void
1702 ip2_hangup ( PTTY tty )
1703 {
1704 i2ChanStrPtr pCh = tty->driver_data;
1705
1706 if( !pCh ) {
1707 return;
1708 }
1709
1710 ip2trace (CHANN, ITRC_HANGUP, ITRC_ENTER, 0 );
1711
1712 ip2_flush_buffer(tty);
1713
1714 /* disable DSS reporting */
1715
1716 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_DCD_NREP);
1717 i2QueueCommands(PTYPE_INLINE, pCh, 0, 2, CMD_CTSFL_DSAB, CMD_RTSFL_DSAB);
1718 if ( (tty->termios->c_cflag & HUPCL) ) {
1719 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 2, CMD_RTSDN, CMD_DTRDN);
1720 pCh->dataSetOut &= ~(I2_DTR | I2_RTS);
1721 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_PAUSE(25));
1722 }
1723 i2QueueCommands(PTYPE_INLINE, pCh, 1, 3,
1724 CMD_CTS_NREP, CMD_DSR_NREP, CMD_RI_NREP);
1725 serviceOutgoingFifo ( pCh->pMyBord );
1726
1727 wake_up_interruptible ( &pCh->delta_msr_wait );
1728
1729 pCh->flags &= ~ASYNC_NORMAL_ACTIVE;
1730 pCh->pTTY = NULL;
1731 wake_up_interruptible ( &pCh->open_wait );
1732
1733 ip2trace (CHANN, ITRC_HANGUP, ITRC_RETURN, 0 );
1734 }
1735
1736 /******************************************************************************/
1737 /******************************************************************************/
1738 /* Device Output Section */
1739 /******************************************************************************/
1740 /******************************************************************************/
1741
1742 /******************************************************************************/
1743 /* Function: ip2_write() */
1744 /* Parameters: Pointer to tty structure */
1745 /* Flag denoting data is in user (1) or kernel (0) space */
1746 /* Pointer to data */
1747 /* Number of bytes to write */
1748 /* Returns: Number of bytes actually written */
1749 /* */
1750 /* Description: (MANDATORY) */
1751 /* */
1752 /* */
1753 /******************************************************************************/
1754 static int
1755 ip2_write( PTTY tty, const unsigned char *pData, int count)
1756 {
1757 i2ChanStrPtr pCh = tty->driver_data;
1758 int bytesSent = 0;
1759 unsigned long flags;
1760
1761 ip2trace (CHANN, ITRC_WRITE, ITRC_ENTER, 2, count, -1 );
1762
1763 /* Flush out any buffered data left over from ip2_putchar() calls. */
1764 ip2_flush_chars( tty );
1765
1766 /* This is the actual move bit. Make sure it does what we need!!!!! */
1767 write_lock_irqsave(&pCh->Pbuf_spinlock, flags);
1768 bytesSent = i2Output( pCh, pData, count);
1769 write_unlock_irqrestore(&pCh->Pbuf_spinlock, flags);
1770
1771 ip2trace (CHANN, ITRC_WRITE, ITRC_RETURN, 1, bytesSent );
1772
1773 return bytesSent > 0 ? bytesSent : 0;
1774 }
1775
1776 /******************************************************************************/
1777 /* Function: ip2_putchar() */
1778 /* Parameters: Pointer to tty structure */
1779 /* Character to write */
1780 /* Returns: Nothing */
1781 /* */
1782 /* Description: */
1783 /* */
1784 /* */
1785 /******************************************************************************/
1786 static int
1787 ip2_putchar( PTTY tty, unsigned char ch )
1788 {
1789 i2ChanStrPtr pCh = tty->driver_data;
1790 unsigned long flags;
1791
1792 // ip2trace (CHANN, ITRC_PUTC, ITRC_ENTER, 1, ch );
1793
1794 write_lock_irqsave(&pCh->Pbuf_spinlock, flags);
1795 pCh->Pbuf[pCh->Pbuf_stuff++] = ch;
1796 if ( pCh->Pbuf_stuff == sizeof pCh->Pbuf ) {
1797 write_unlock_irqrestore(&pCh->Pbuf_spinlock, flags);
1798 ip2_flush_chars( tty );
1799 } else
1800 write_unlock_irqrestore(&pCh->Pbuf_spinlock, flags);
1801 return 1;
1802
1803 // ip2trace (CHANN, ITRC_PUTC, ITRC_RETURN, 1, ch );
1804 }
1805
1806 /******************************************************************************/
1807 /* Function: ip2_flush_chars() */
1808 /* Parameters: Pointer to tty structure */
1809 /* Returns: Nothing */
1810 /* */
1811 /* Description: */
1812 /* */
1813 /******************************************************************************/
1814 static void
1815 ip2_flush_chars( PTTY tty )
1816 {
1817 int strip;
1818 i2ChanStrPtr pCh = tty->driver_data;
1819 unsigned long flags;
1820
1821 write_lock_irqsave(&pCh->Pbuf_spinlock, flags);
1822 if ( pCh->Pbuf_stuff ) {
1823
1824 // ip2trace (CHANN, ITRC_PUTC, 10, 1, strip );
1825
1826 //
1827 // We may need to restart i2Output if it does not fulfill this request
1828 //
1829 strip = i2Output( pCh, pCh->Pbuf, pCh->Pbuf_stuff);
1830 if ( strip != pCh->Pbuf_stuff ) {
1831 memmove( pCh->Pbuf, &pCh->Pbuf[strip], pCh->Pbuf_stuff - strip );
1832 }
1833 pCh->Pbuf_stuff -= strip;
1834 }
1835 write_unlock_irqrestore(&pCh->Pbuf_spinlock, flags);
1836 }
1837
1838 /******************************************************************************/
1839 /* Function: ip2_write_room() */
1840 /* Parameters: Pointer to tty structure */
1841 /* Returns: Number of bytes that the driver can accept */
1842 /* */
1843 /* Description: */
1844 /* */
1845 /******************************************************************************/
1846 static int
1847 ip2_write_room ( PTTY tty )
1848 {
1849 int bytesFree;
1850 i2ChanStrPtr pCh = tty->driver_data;
1851 unsigned long flags;
1852
1853 read_lock_irqsave(&pCh->Pbuf_spinlock, flags);
1854 bytesFree = i2OutputFree( pCh ) - pCh->Pbuf_stuff;
1855 read_unlock_irqrestore(&pCh->Pbuf_spinlock, flags);
1856
1857 ip2trace (CHANN, ITRC_WRITE, 11, 1, bytesFree );
1858
1859 return ((bytesFree > 0) ? bytesFree : 0);
1860 }
1861
1862 /******************************************************************************/
1863 /* Function: ip2_chars_in_buf() */
1864 /* Parameters: Pointer to tty structure */
1865 /* Returns: Number of bytes queued for transmission */
1866 /* */
1867 /* Description: */
1868 /* */
1869 /* */
1870 /******************************************************************************/
1871 static int
1872 ip2_chars_in_buf ( PTTY tty )
1873 {
1874 i2ChanStrPtr pCh = tty->driver_data;
1875 int rc;
1876 unsigned long flags;
1877
1878 ip2trace (CHANN, ITRC_WRITE, 12, 1, pCh->Obuf_char_count + pCh->Pbuf_stuff );
1879
1880 #ifdef IP2DEBUG_WRITE
1881 printk (KERN_DEBUG "IP2: chars in buffer = %d (%d,%d)\n",
1882 pCh->Obuf_char_count + pCh->Pbuf_stuff,
1883 pCh->Obuf_char_count, pCh->Pbuf_stuff );
1884 #endif
1885 read_lock_irqsave(&pCh->Obuf_spinlock, flags);
1886 rc = pCh->Obuf_char_count;
1887 read_unlock_irqrestore(&pCh->Obuf_spinlock, flags);
1888 read_lock_irqsave(&pCh->Pbuf_spinlock, flags);
1889 rc += pCh->Pbuf_stuff;
1890 read_unlock_irqrestore(&pCh->Pbuf_spinlock, flags);
1891 return rc;
1892 }
1893
1894 /******************************************************************************/
1895 /* Function: ip2_flush_buffer() */
1896 /* Parameters: Pointer to tty structure */
1897 /* Returns: Nothing */
1898 /* */
1899 /* Description: */
1900 /* */
1901 /* */
1902 /******************************************************************************/
1903 static void
1904 ip2_flush_buffer( PTTY tty )
1905 {
1906 i2ChanStrPtr pCh = tty->driver_data;
1907 unsigned long flags;
1908
1909 ip2trace (CHANN, ITRC_FLUSH, ITRC_ENTER, 0 );
1910
1911 #ifdef IP2DEBUG_WRITE
1912 printk (KERN_DEBUG "IP2: flush buffer\n" );
1913 #endif
1914 write_lock_irqsave(&pCh->Pbuf_spinlock, flags);
1915 pCh->Pbuf_stuff = 0;
1916 write_unlock_irqrestore(&pCh->Pbuf_spinlock, flags);
1917 i2FlushOutput( pCh );
1918 ip2_owake(tty);
1919
1920 ip2trace (CHANN, ITRC_FLUSH, ITRC_RETURN, 0 );
1921
1922 }
1923
1924 /******************************************************************************/
1925 /* Function: ip2_wait_until_sent() */
1926 /* Parameters: Pointer to tty structure */
1927 /* Timeout for wait. */
1928 /* Returns: Nothing */
1929 /* */
1930 /* Description: */
1931 /* This function is used in place of the normal tty_wait_until_sent, which */
1932 /* only waits for the driver buffers to be empty (or rather, those buffers */
1933 /* reported by chars_in_buffer) which doesn't work for IP2 due to the */
1934 /* indeterminate number of bytes buffered on the board. */
1935 /******************************************************************************/
1936 static void
1937 ip2_wait_until_sent ( PTTY tty, int timeout )
1938 {
1939 int i = jiffies;
1940 i2ChanStrPtr pCh = tty->driver_data;
1941
1942 tty_wait_until_sent(tty, timeout );
1943 if ( (i = timeout - (jiffies -i)) > 0)
1944 i2DrainOutput( pCh, i );
1945 }
1946
1947 /******************************************************************************/
1948 /******************************************************************************/
1949 /* Device Input Section */
1950 /******************************************************************************/
1951 /******************************************************************************/
1952
1953 /******************************************************************************/
1954 /* Function: ip2_throttle() */
1955 /* Parameters: Pointer to tty structure */
1956 /* Returns: Nothing */
1957 /* */
1958 /* Description: */
1959 /* */
1960 /* */
1961 /******************************************************************************/
1962 static void
1963 ip2_throttle ( PTTY tty )
1964 {
1965 i2ChanStrPtr pCh = tty->driver_data;
1966
1967 #ifdef IP2DEBUG_READ
1968 printk (KERN_DEBUG "IP2: throttle\n" );
1969 #endif
1970 /*
1971 * Signal the poll/interrupt handlers not to forward incoming data to
1972 * the line discipline. This will cause the buffers to fill up in the
1973 * library and thus cause the library routines to send the flow control
1974 * stuff.
1975 */
1976 pCh->throttled = 1;
1977 }
1978
1979 /******************************************************************************/
1980 /* Function: ip2_unthrottle() */
1981 /* Parameters: Pointer to tty structure */
1982 /* Returns: Nothing */
1983 /* */
1984 /* Description: */
1985 /* */
1986 /* */
1987 /******************************************************************************/
1988 static void
1989 ip2_unthrottle ( PTTY tty )
1990 {
1991 i2ChanStrPtr pCh = tty->driver_data;
1992 unsigned long flags;
1993
1994 #ifdef IP2DEBUG_READ
1995 printk (KERN_DEBUG "IP2: unthrottle\n" );
1996 #endif
1997
1998 /* Pass incoming data up to the line discipline again. */
1999 pCh->throttled = 0;
2000 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_RESUME);
2001 serviceOutgoingFifo( pCh->pMyBord );
2002 read_lock_irqsave(&pCh->Ibuf_spinlock, flags);
2003 if ( pCh->Ibuf_stuff != pCh->Ibuf_strip ) {
2004 read_unlock_irqrestore(&pCh->Ibuf_spinlock, flags);
2005 #ifdef IP2DEBUG_READ
2006 printk (KERN_DEBUG "i2Input called from unthrottle\n" );
2007 #endif
2008 i2Input( pCh );
2009 } else
2010 read_unlock_irqrestore(&pCh->Ibuf_spinlock, flags);
2011 }
2012
2013 static void
2014 ip2_start ( PTTY tty )
2015 {
2016 i2ChanStrPtr pCh = DevTable[tty->index];
2017
2018 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_RESUME);
2019 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_UNSUSPEND);
2020 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_RESUME);
2021 #ifdef IP2DEBUG_WRITE
2022 printk (KERN_DEBUG "IP2: start tx\n" );
2023 #endif
2024 }
2025
2026 static void
2027 ip2_stop ( PTTY tty )
2028 {
2029 i2ChanStrPtr pCh = DevTable[tty->index];
2030
2031 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_SUSPEND);
2032 #ifdef IP2DEBUG_WRITE
2033 printk (KERN_DEBUG "IP2: stop tx\n" );
2034 #endif
2035 }
2036
2037 /******************************************************************************/
2038 /* Device Ioctl Section */
2039 /******************************************************************************/
2040
2041 static int ip2_tiocmget(struct tty_struct *tty)
2042 {
2043 i2ChanStrPtr pCh = DevTable[tty->index];
2044 #ifdef ENABLE_DSSNOW
2045 wait_queue_t wait;
2046 #endif
2047
2048 if (pCh == NULL)
2049 return -ENODEV;
2050
2051 /*
2052 FIXME - the following code is causing a NULL pointer dereference in
2053 2.3.51 in an interrupt handler. It's suppose to prompt the board
2054 to return the DSS signal status immediately. Why doesn't it do
2055 the same thing in 2.2.14?
2056 */
2057
2058 /* This thing is still busted in the 1.2.12 driver on 2.4.x
2059 and even hoses the serial console so the oops can be trapped.
2060 /\/\|=mhw=|\/\/ */
2061
2062 #ifdef ENABLE_DSSNOW
2063 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_DSS_NOW);
2064
2065 init_waitqueue_entry(&wait, current);
2066 add_wait_queue(&pCh->dss_now_wait, &wait);
2067 set_current_state( TASK_INTERRUPTIBLE );
2068
2069 serviceOutgoingFifo( pCh->pMyBord );
2070
2071 schedule();
2072
2073 set_current_state( TASK_RUNNING );
2074 remove_wait_queue(&pCh->dss_now_wait, &wait);
2075
2076 if (signal_pending(current)) {
2077 return -EINTR;
2078 }
2079 #endif
2080 return ((pCh->dataSetOut & I2_RTS) ? TIOCM_RTS : 0)
2081 | ((pCh->dataSetOut & I2_DTR) ? TIOCM_DTR : 0)
2082 | ((pCh->dataSetIn & I2_DCD) ? TIOCM_CAR : 0)
2083 | ((pCh->dataSetIn & I2_RI) ? TIOCM_RNG : 0)
2084 | ((pCh->dataSetIn & I2_DSR) ? TIOCM_DSR : 0)
2085 | ((pCh->dataSetIn & I2_CTS) ? TIOCM_CTS : 0);
2086 }
2087
2088 static int ip2_tiocmset(struct tty_struct *tty,
2089 unsigned int set, unsigned int clear)
2090 {
2091 i2ChanStrPtr pCh = DevTable[tty->index];
2092
2093 if (pCh == NULL)
2094 return -ENODEV;
2095
2096 if (set & TIOCM_RTS) {
2097 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_RTSUP);
2098 pCh->dataSetOut |= I2_RTS;
2099 }
2100 if (set & TIOCM_DTR) {
2101 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DTRUP);
2102 pCh->dataSetOut |= I2_DTR;
2103 }
2104
2105 if (clear & TIOCM_RTS) {
2106 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_RTSDN);
2107 pCh->dataSetOut &= ~I2_RTS;
2108 }
2109 if (clear & TIOCM_DTR) {
2110 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DTRDN);
2111 pCh->dataSetOut &= ~I2_DTR;
2112 }
2113 serviceOutgoingFifo( pCh->pMyBord );
2114 return 0;
2115 }
2116
2117 /******************************************************************************/
2118 /* Function: ip2_ioctl() */
2119 /* Parameters: Pointer to tty structure */
2120 /* Pointer to file structure */
2121 /* Command */
2122 /* Argument */
2123 /* Returns: Success or failure */
2124 /* */
2125 /* Description: */
2126 /* */
2127 /* */
2128 /******************************************************************************/
2129 static int
2130 ip2_ioctl ( PTTY tty, UINT cmd, ULONG arg )
2131 {
2132 wait_queue_t wait;
2133 i2ChanStrPtr pCh = DevTable[tty->index];
2134 i2eBordStrPtr pB;
2135 struct async_icount cprev, cnow; /* kernel counter temps */
2136 int rc = 0;
2137 unsigned long flags;
2138 void __user *argp = (void __user *)arg;
2139
2140 if ( pCh == NULL )
2141 return -ENODEV;
2142
2143 pB = pCh->pMyBord;
2144
2145 ip2trace (CHANN, ITRC_IOCTL, ITRC_ENTER, 2, cmd, arg );
2146
2147 #ifdef IP2DEBUG_IOCTL
2148 printk(KERN_DEBUG "IP2: ioctl cmd (%x), arg (%lx)\n", cmd, arg );
2149 #endif
2150
2151 switch(cmd) {
2152 case TIOCGSERIAL:
2153
2154 ip2trace (CHANN, ITRC_IOCTL, 2, 1, rc );
2155
2156 rc = get_serial_info(pCh, argp);
2157 if (rc)
2158 return rc;
2159 break;
2160
2161 case TIOCSSERIAL:
2162
2163 ip2trace (CHANN, ITRC_IOCTL, 3, 1, rc );
2164
2165 rc = set_serial_info(pCh, argp);
2166 if (rc)
2167 return rc;
2168 break;
2169
2170 case TCXONC:
2171 rc = tty_check_change(tty);
2172 if (rc)
2173 return rc;
2174 switch (arg) {
2175 case TCOOFF:
2176 //return -ENOIOCTLCMD;
2177 break;
2178 case TCOON:
2179 //return -ENOIOCTLCMD;
2180 break;
2181 case TCIOFF:
2182 if (STOP_CHAR(tty) != __DISABLED_CHAR) {
2183 i2QueueCommands( PTYPE_BYPASS, pCh, 100, 1,
2184 CMD_XMIT_NOW(STOP_CHAR(tty)));
2185 }
2186 break;
2187 case TCION:
2188 if (START_CHAR(tty) != __DISABLED_CHAR) {
2189 i2QueueCommands( PTYPE_BYPASS, pCh, 100, 1,
2190 CMD_XMIT_NOW(START_CHAR(tty)));
2191 }
2192 break;
2193 default:
2194 return -EINVAL;
2195 }
2196 return 0;
2197
2198 case TCSBRK: /* SVID version: non-zero arg --> no break */
2199 rc = tty_check_change(tty);
2200
2201 ip2trace (CHANN, ITRC_IOCTL, 4, 1, rc );
2202
2203 if (!rc) {
2204 ip2_wait_until_sent(tty,0);
2205 if (!arg) {
2206 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_SEND_BRK(250));
2207 serviceOutgoingFifo( pCh->pMyBord );
2208 }
2209 }
2210 break;
2211
2212 case TCSBRKP: /* support for POSIX tcsendbreak() */
2213 rc = tty_check_change(tty);
2214
2215 ip2trace (CHANN, ITRC_IOCTL, 5, 1, rc );
2216
2217 if (!rc) {
2218 ip2_wait_until_sent(tty,0);
2219 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1,
2220 CMD_SEND_BRK(arg ? arg*100 : 250));
2221 serviceOutgoingFifo ( pCh->pMyBord );
2222 }
2223 break;
2224
2225 case TIOCGSOFTCAR:
2226
2227 ip2trace (CHANN, ITRC_IOCTL, 6, 1, rc );
2228
2229 rc = put_user(C_CLOCAL(tty) ? 1 : 0, (unsigned long __user *)argp);
2230 if (rc)
2231 return rc;
2232 break;
2233
2234 case TIOCSSOFTCAR:
2235
2236 ip2trace (CHANN, ITRC_IOCTL, 7, 1, rc );
2237
2238 rc = get_user(arg,(unsigned long __user *) argp);
2239 if (rc)
2240 return rc;
2241 tty->termios->c_cflag = ((tty->termios->c_cflag & ~CLOCAL)
2242 | (arg ? CLOCAL : 0));
2243
2244 break;
2245
2246 /*
2247 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change - mask
2248 * passed in arg for lines of interest (use |'ed TIOCM_RNG/DSR/CD/CTS
2249 * for masking). Caller should use TIOCGICOUNT to see which one it was
2250 */
2251 case TIOCMIWAIT:
2252 write_lock_irqsave(&pB->read_fifo_spinlock, flags);
2253 cprev = pCh->icount; /* note the counters on entry */
2254 write_unlock_irqrestore(&pB->read_fifo_spinlock, flags);
2255 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 4,
2256 CMD_DCD_REP, CMD_CTS_REP, CMD_DSR_REP, CMD_RI_REP);
2257 init_waitqueue_entry(&wait, current);
2258 add_wait_queue(&pCh->delta_msr_wait, &wait);
2259 set_current_state( TASK_INTERRUPTIBLE );
2260
2261 serviceOutgoingFifo( pCh->pMyBord );
2262 for(;;) {
2263 ip2trace (CHANN, ITRC_IOCTL, 10, 0 );
2264
2265 schedule();
2266
2267 ip2trace (CHANN, ITRC_IOCTL, 11, 0 );
2268
2269 /* see if a signal did it */
2270 if (signal_pending(current)) {
2271 rc = -ERESTARTSYS;
2272 break;
2273 }
2274 write_lock_irqsave(&pB->read_fifo_spinlock, flags);
2275 cnow = pCh->icount; /* atomic copy */
2276 write_unlock_irqrestore(&pB->read_fifo_spinlock, flags);
2277 if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
2278 cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) {
2279 rc = -EIO; /* no change => rc */
2280 break;
2281 }
2282 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
2283 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
2284 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
2285 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)) ) {
2286 rc = 0;
2287 break;
2288 }
2289 cprev = cnow;
2290 }
2291 set_current_state( TASK_RUNNING );
2292 remove_wait_queue(&pCh->delta_msr_wait, &wait);
2293
2294 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 3,
2295 CMD_CTS_NREP, CMD_DSR_NREP, CMD_RI_NREP);
2296 if ( ! (pCh->flags & ASYNC_CHECK_CD)) {
2297 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_DCD_NREP);
2298 }
2299 serviceOutgoingFifo( pCh->pMyBord );
2300 return rc;
2301 break;
2302
2303 /*
2304 * The rest are not supported by this driver. By returning -ENOIOCTLCMD they
2305 * will be passed to the line discipline for it to handle.
2306 */
2307 case TIOCSERCONFIG:
2308 case TIOCSERGWILD:
2309 case TIOCSERGETLSR:
2310 case TIOCSERSWILD:
2311 case TIOCSERGSTRUCT:
2312 case TIOCSERGETMULTI:
2313 case TIOCSERSETMULTI:
2314
2315 default:
2316 ip2trace (CHANN, ITRC_IOCTL, 12, 0 );
2317
2318 rc = -ENOIOCTLCMD;
2319 break;
2320 }
2321
2322 ip2trace (CHANN, ITRC_IOCTL, ITRC_RETURN, 0 );
2323
2324 return rc;
2325 }
2326
2327 static int ip2_get_icount(struct tty_struct *tty,
2328 struct serial_icounter_struct *icount)
2329 {
2330 i2ChanStrPtr pCh = DevTable[tty->index];
2331 i2eBordStrPtr pB;
2332 struct async_icount cnow; /* kernel counter temp */
2333 unsigned long flags;
2334
2335 if ( pCh == NULL )
2336 return -ENODEV;
2337
2338 pB = pCh->pMyBord;
2339
2340 /*
2341 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
2342 * Return: write counters to the user passed counter struct
2343 * NB: both 1->0 and 0->1 transitions are counted except for RI where
2344 * only 0->1 is counted. The controller is quite capable of counting
2345 * both, but this done to preserve compatibility with the standard
2346 * serial driver.
2347 */
2348
2349 write_lock_irqsave(&pB->read_fifo_spinlock, flags);
2350 cnow = pCh->icount;
2351 write_unlock_irqrestore(&pB->read_fifo_spinlock, flags);
2352
2353 icount->cts = cnow.cts;
2354 icount->dsr = cnow.dsr;
2355 icount->rng = cnow.rng;
2356 icount->dcd = cnow.dcd;
2357 icount->rx = cnow.rx;
2358 icount->tx = cnow.tx;
2359 icount->frame = cnow.frame;
2360 icount->overrun = cnow.overrun;
2361 icount->parity = cnow.parity;
2362 icount->brk = cnow.brk;
2363 icount->buf_overrun = cnow.buf_overrun;
2364 return 0;
2365 }
2366
2367 /******************************************************************************/
2368 /* Function: GetSerialInfo() */
2369 /* Parameters: Pointer to channel structure */
2370 /* Pointer to old termios structure */
2371 /* Returns: Nothing */
2372 /* */
2373 /* Description: */
2374 /* This is to support the setserial command, and requires processing of the */
2375 /* standard Linux serial structure. */
2376 /******************************************************************************/
2377 static int
2378 get_serial_info ( i2ChanStrPtr pCh, struct serial_struct __user *retinfo )
2379 {
2380 struct serial_struct tmp;
2381
2382 memset ( &tmp, 0, sizeof(tmp) );
2383 tmp.type = pCh->pMyBord->channelBtypes.bid_value[(pCh->port_index & (IP2_PORTS_PER_BOARD-1))/16];
2384 if (BID_HAS_654(tmp.type)) {
2385 tmp.type = PORT_16650;
2386 } else {
2387 tmp.type = PORT_CIRRUS;
2388 }
2389 tmp.line = pCh->port_index;
2390 tmp.port = pCh->pMyBord->i2eBase;
2391 tmp.irq = ip2config.irq[pCh->port_index/64];
2392 tmp.flags = pCh->flags;
2393 tmp.baud_base = pCh->BaudBase;
2394 tmp.close_delay = pCh->ClosingDelay;
2395 tmp.closing_wait = pCh->ClosingWaitTime;
2396 tmp.custom_divisor = pCh->BaudDivisor;
2397 return copy_to_user(retinfo,&tmp,sizeof(*retinfo));
2398 }
2399
2400 /******************************************************************************/
2401 /* Function: SetSerialInfo() */
2402 /* Parameters: Pointer to channel structure */
2403 /* Pointer to old termios structure */
2404 /* Returns: Nothing */
2405 /* */
2406 /* Description: */
2407 /* This function provides support for setserial, which uses the TIOCSSERIAL */
2408 /* ioctl. Not all setserial parameters are relevant. If the user attempts to */
2409 /* change the IRQ, address or type of the port the ioctl fails. */
2410 /******************************************************************************/
2411 static int
2412 set_serial_info( i2ChanStrPtr pCh, struct serial_struct __user *new_info )
2413 {
2414 struct serial_struct ns;
2415 int old_flags, old_baud_divisor;
2416
2417 if (copy_from_user(&ns, new_info, sizeof (ns)))
2418 return -EFAULT;
2419
2420 /*
2421 * We don't allow setserial to change IRQ, board address, type or baud
2422 * base. Also line nunber as such is meaningless but we use it for our
2423 * array index so it is fixed also.
2424 */
2425 if ( (ns.irq != ip2config.irq[pCh->port_index])
2426 || ((int) ns.port != ((int) (pCh->pMyBord->i2eBase)))
2427 || (ns.baud_base != pCh->BaudBase)
2428 || (ns.line != pCh->port_index) ) {
2429 return -EINVAL;
2430 }
2431
2432 old_flags = pCh->flags;
2433 old_baud_divisor = pCh->BaudDivisor;
2434
2435 if ( !capable(CAP_SYS_ADMIN) ) {
2436 if ( ( ns.close_delay != pCh->ClosingDelay ) ||
2437 ( (ns.flags & ~ASYNC_USR_MASK) !=
2438 (pCh->flags & ~ASYNC_USR_MASK) ) ) {
2439 return -EPERM;
2440 }
2441
2442 pCh->flags = (pCh->flags & ~ASYNC_USR_MASK) |
2443 (ns.flags & ASYNC_USR_MASK);
2444 pCh->BaudDivisor = ns.custom_divisor;
2445 } else {
2446 pCh->flags = (pCh->flags & ~ASYNC_FLAGS) |
2447 (ns.flags & ASYNC_FLAGS);
2448 pCh->BaudDivisor = ns.custom_divisor;
2449 pCh->ClosingDelay = ns.close_delay * HZ/100;
2450 pCh->ClosingWaitTime = ns.closing_wait * HZ/100;
2451 }
2452
2453 if ( ( (old_flags & ASYNC_SPD_MASK) != (pCh->flags & ASYNC_SPD_MASK) )
2454 || (old_baud_divisor != pCh->BaudDivisor) ) {
2455 // Invalidate speed and reset parameters
2456 set_params( pCh, NULL );
2457 }
2458
2459 return 0;
2460 }
2461
2462 /******************************************************************************/
2463 /* Function: ip2_set_termios() */
2464 /* Parameters: Pointer to tty structure */
2465 /* Pointer to old termios structure */
2466 /* Returns: Nothing */
2467 /* */
2468 /* Description: */
2469 /* */
2470 /* */
2471 /******************************************************************************/
2472 static void
2473 ip2_set_termios( PTTY tty, struct ktermios *old_termios )
2474 {
2475 i2ChanStrPtr pCh = (i2ChanStrPtr)tty->driver_data;
2476
2477 #ifdef IP2DEBUG_IOCTL
2478 printk (KERN_DEBUG "IP2: set termios %p\n", old_termios );
2479 #endif
2480
2481 set_params( pCh, old_termios );
2482 }
2483
2484 /******************************************************************************/
2485 /* Function: ip2_set_line_discipline() */
2486 /* Parameters: Pointer to tty structure */
2487 /* Returns: Nothing */
2488 /* */
2489 /* Description: Does nothing */
2490 /* */
2491 /* */
2492 /******************************************************************************/
2493 static void
2494 ip2_set_line_discipline ( PTTY tty )
2495 {
2496 #ifdef IP2DEBUG_IOCTL
2497 printk (KERN_DEBUG "IP2: set line discipline\n" );
2498 #endif
2499
2500 ip2trace (((i2ChanStrPtr)tty->driver_data)->port_index, ITRC_IOCTL, 16, 0 );
2501
2502 }
2503
2504 /******************************************************************************/
2505 /* Function: SetLine Characteristics() */
2506 /* Parameters: Pointer to channel structure */
2507 /* Returns: Nothing */
2508 /* */
2509 /* Description: */
2510 /* This routine is called to update the channel structure with the new line */
2511 /* characteristics, and send the appropriate commands to the board when they */
2512 /* change. */
2513 /******************************************************************************/
2514 static void
2515 set_params( i2ChanStrPtr pCh, struct ktermios *o_tios )
2516 {
2517 tcflag_t cflag, iflag, lflag;
2518 char stop_char, start_char;
2519 struct ktermios dummy;
2520
2521 lflag = pCh->pTTY->termios->c_lflag;
2522 cflag = pCh->pTTY->termios->c_cflag;
2523 iflag = pCh->pTTY->termios->c_iflag;
2524
2525 if (o_tios == NULL) {
2526 dummy.c_lflag = ~lflag;
2527 dummy.c_cflag = ~cflag;
2528 dummy.c_iflag = ~iflag;
2529 o_tios = &dummy;
2530 }
2531
2532 {
2533 switch ( cflag & CBAUD ) {
2534 case B0:
2535 i2QueueCommands( PTYPE_BYPASS, pCh, 100, 2, CMD_RTSDN, CMD_DTRDN);
2536 pCh->dataSetOut &= ~(I2_DTR | I2_RTS);
2537 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_PAUSE(25));
2538 pCh->pTTY->termios->c_cflag |= (CBAUD & o_tios->c_cflag);
2539 goto service_it;
2540 break;
2541 case B38400:
2542 /*
2543 * This is the speed that is overloaded with all the other high
2544 * speeds, depending upon the flag settings.
2545 */
2546 if ( ( pCh->flags & ASYNC_SPD_MASK ) == ASYNC_SPD_HI ) {
2547 pCh->speed = CBR_57600;
2548 } else if ( (pCh->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI ) {
2549 pCh->speed = CBR_115200;
2550 } else if ( (pCh->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST ) {
2551 pCh->speed = CBR_C1;
2552 } else {
2553 pCh->speed = CBR_38400;
2554 }
2555 break;
2556 case B50: pCh->speed = CBR_50; break;
2557 case B75: pCh->speed = CBR_75; break;
2558 case B110: pCh->speed = CBR_110; break;
2559 case B134: pCh->speed = CBR_134; break;
2560 case B150: pCh->speed = CBR_150; break;
2561 case B200: pCh->speed = CBR_200; break;
2562 case B300: pCh->speed = CBR_300; break;
2563 case B600: pCh->speed = CBR_600; break;
2564 case B1200: pCh->speed = CBR_1200; break;
2565 case B1800: pCh->speed = CBR_1800; break;
2566 case B2400: pCh->speed = CBR_2400; break;
2567 case B4800: pCh->speed = CBR_4800; break;
2568 case B9600: pCh->speed = CBR_9600; break;
2569 case B19200: pCh->speed = CBR_19200; break;
2570 case B57600: pCh->speed = CBR_57600; break;
2571 case B115200: pCh->speed = CBR_115200; break;
2572 case B153600: pCh->speed = CBR_153600; break;
2573 case B230400: pCh->speed = CBR_230400; break;
2574 case B307200: pCh->speed = CBR_307200; break;
2575 case B460800: pCh->speed = CBR_460800; break;
2576 case B921600: pCh->speed = CBR_921600; break;
2577 default: pCh->speed = CBR_9600; break;
2578 }
2579 if ( pCh->speed == CBR_C1 ) {
2580 // Process the custom speed parameters.
2581 int bps = pCh->BaudBase / pCh->BaudDivisor;
2582 if ( bps == 921600 ) {
2583 pCh->speed = CBR_921600;
2584 } else {
2585 bps = bps/10;
2586 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_BAUD_DEF1(bps) );
2587 }
2588 }
2589 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_SETBAUD(pCh->speed));
2590
2591 i2QueueCommands ( PTYPE_INLINE, pCh, 100, 2, CMD_DTRUP, CMD_RTSUP);
2592 pCh->dataSetOut |= (I2_DTR | I2_RTS);
2593 }
2594 if ( (CSTOPB & cflag) ^ (CSTOPB & o_tios->c_cflag))
2595 {
2596 i2QueueCommands ( PTYPE_INLINE, pCh, 100, 1,
2597 CMD_SETSTOP( ( cflag & CSTOPB ) ? CST_2 : CST_1));
2598 }
2599 if (((PARENB|PARODD) & cflag) ^ ((PARENB|PARODD) & o_tios->c_cflag))
2600 {
2601 i2QueueCommands ( PTYPE_INLINE, pCh, 100, 1,
2602 CMD_SETPAR(
2603 (cflag & PARENB ? (cflag & PARODD ? CSP_OD : CSP_EV) : CSP_NP)
2604 )
2605 );
2606 }
2607 /* byte size and parity */
2608 if ( (CSIZE & cflag)^(CSIZE & o_tios->c_cflag))
2609 {
2610 int datasize;
2611 switch ( cflag & CSIZE ) {
2612 case CS5: datasize = CSZ_5; break;
2613 case CS6: datasize = CSZ_6; break;
2614 case CS7: datasize = CSZ_7; break;
2615 case CS8: datasize = CSZ_8; break;
2616 default: datasize = CSZ_5; break; /* as per serial.c */
2617 }
2618 i2QueueCommands ( PTYPE_INLINE, pCh, 100, 1, CMD_SETBITS(datasize) );
2619 }
2620 /* Process CTS flow control flag setting */
2621 if ( (cflag & CRTSCTS) ) {
2622 i2QueueCommands(PTYPE_INLINE, pCh, 100,
2623 2, CMD_CTSFL_ENAB, CMD_RTSFL_ENAB);
2624 } else {
2625 i2QueueCommands(PTYPE_INLINE, pCh, 100,
2626 2, CMD_CTSFL_DSAB, CMD_RTSFL_DSAB);
2627 }
2628 //
2629 // Process XON/XOFF flow control flags settings
2630 //
2631 stop_char = STOP_CHAR(pCh->pTTY);
2632 start_char = START_CHAR(pCh->pTTY);
2633
2634 //////////// can't be \000
2635 if (stop_char == __DISABLED_CHAR )
2636 {
2637 stop_char = ~__DISABLED_CHAR;
2638 }
2639 if (start_char == __DISABLED_CHAR )
2640 {
2641 start_char = ~__DISABLED_CHAR;
2642 }
2643 /////////////////////////////////
2644
2645 if ( o_tios->c_cc[VSTART] != start_char )
2646 {
2647 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_DEF_IXON(start_char));
2648 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DEF_OXON(start_char));
2649 }
2650 if ( o_tios->c_cc[VSTOP] != stop_char )
2651 {
2652 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_DEF_IXOFF(stop_char));
2653 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DEF_OXOFF(stop_char));
2654 }
2655 if (stop_char == __DISABLED_CHAR )
2656 {
2657 stop_char = ~__DISABLED_CHAR; //TEST123
2658 goto no_xoff;
2659 }
2660 if ((iflag & (IXOFF))^(o_tios->c_iflag & (IXOFF)))
2661 {
2662 if ( iflag & IXOFF ) { // Enable XOFF output flow control
2663 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_OXON_OPT(COX_XON));
2664 } else { // Disable XOFF output flow control
2665 no_xoff:
2666 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_OXON_OPT(COX_NONE));
2667 }
2668 }
2669 if (start_char == __DISABLED_CHAR )
2670 {
2671 goto no_xon;
2672 }
2673 if ((iflag & (IXON|IXANY)) ^ (o_tios->c_iflag & (IXON|IXANY)))
2674 {
2675 if ( iflag & IXON ) {
2676 if ( iflag & IXANY ) { // Enable XON/XANY output flow control
2677 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_IXON_OPT(CIX_XANY));
2678 } else { // Enable XON output flow control
2679 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_IXON_OPT(CIX_XON));
2680 }
2681 } else { // Disable XON output flow control
2682 no_xon:
2683 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_IXON_OPT(CIX_NONE));
2684 }
2685 }
2686 if ( (iflag & ISTRIP) ^ ( o_tios->c_iflag & (ISTRIP)) )
2687 {
2688 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1,
2689 CMD_ISTRIP_OPT((iflag & ISTRIP ? 1 : 0)));
2690 }
2691 if ( (iflag & INPCK) ^ ( o_tios->c_iflag & (INPCK)) )
2692 {
2693 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1,
2694 CMD_PARCHK((iflag & INPCK) ? CPK_ENAB : CPK_DSAB));
2695 }
2696
2697 if ( (iflag & (IGNBRK|PARMRK|BRKINT|IGNPAR))
2698 ^ ( o_tios->c_iflag & (IGNBRK|PARMRK|BRKINT|IGNPAR)) )
2699 {
2700 char brkrpt = 0;
2701 char parrpt = 0;
2702
2703 if ( iflag & IGNBRK ) { /* Ignore breaks altogether */
2704 /* Ignore breaks altogether */
2705 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_BRK_NREP);
2706 } else {
2707 if ( iflag & BRKINT ) {
2708 if ( iflag & PARMRK ) {
2709 brkrpt = 0x0a; // exception an inline triple
2710 } else {
2711 brkrpt = 0x1a; // exception and NULL
2712 }
2713 brkrpt |= 0x04; // flush input
2714 } else {
2715 if ( iflag & PARMRK ) {
2716 brkrpt = 0x0b; //POSIX triple \0377 \0 \0
2717 } else {
2718 brkrpt = 0x01; // Null only
2719 }
2720 }
2721 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_BRK_REP(brkrpt));
2722 }
2723
2724 if (iflag & IGNPAR) {
2725 parrpt = 0x20;
2726 /* would be 2 for not cirrus bug */
2727 /* would be 0x20 cept for cirrus bug */
2728 } else {
2729 if ( iflag & PARMRK ) {
2730 /*
2731 * Replace error characters with 3-byte sequence (\0377,\0,char)
2732 */
2733 parrpt = 0x04 ;
2734 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_ISTRIP_OPT((char)0));
2735 } else {
2736 parrpt = 0x03;
2737 }
2738 }
2739 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_SET_ERROR(parrpt));
2740 }
2741 if (cflag & CLOCAL) {
2742 // Status reporting fails for DCD if this is off
2743 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DCD_NREP);
2744 pCh->flags &= ~ASYNC_CHECK_CD;
2745 } else {
2746 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DCD_REP);
2747 pCh->flags |= ASYNC_CHECK_CD;
2748 }
2749
2750 service_it:
2751 i2DrainOutput( pCh, 100 );
2752 }
2753
2754 /******************************************************************************/
2755 /* IPL Device Section */
2756 /******************************************************************************/
2757
2758 /******************************************************************************/
2759 /* Function: ip2_ipl_read() */
2760 /* Parameters: Pointer to device inode */
2761 /* Pointer to file structure */
2762 /* Pointer to data */
2763 /* Number of bytes to read */
2764 /* Returns: Success or failure */
2765 /* */
2766 /* Description: Ugly */
2767 /* */
2768 /* */
2769 /******************************************************************************/
2770
2771 static
2772 ssize_t
2773 ip2_ipl_read(struct file *pFile, char __user *pData, size_t count, loff_t *off )
2774 {
2775 unsigned int minor = iminor(pFile->f_path.dentry->d_inode);
2776 int rc = 0;
2777
2778 #ifdef IP2DEBUG_IPL
2779 printk (KERN_DEBUG "IP2IPL: read %p, %d bytes\n", pData, count );
2780 #endif
2781
2782 switch( minor ) {
2783 case 0: // IPL device
2784 rc = -EINVAL;
2785 break;
2786 case 1: // Status dump
2787 rc = -EINVAL;
2788 break;
2789 case 2: // Ping device
2790 rc = -EINVAL;
2791 break;
2792 case 3: // Trace device
2793 rc = DumpTraceBuffer ( pData, count );
2794 break;
2795 case 4: // Trace device
2796 rc = DumpFifoBuffer ( pData, count );
2797 break;
2798 default:
2799 rc = -ENODEV;
2800 break;
2801 }
2802 return rc;
2803 }
2804
2805 static int
2806 DumpFifoBuffer ( char __user *pData, int count )
2807 {
2808 #ifdef DEBUG_FIFO
2809 int rc;
2810 rc = copy_to_user(pData, DBGBuf, count);
2811
2812 printk(KERN_DEBUG "Last index %d\n", I );
2813
2814 return count;
2815 #endif /* DEBUG_FIFO */
2816 return 0;
2817 }
2818
2819 static int
2820 DumpTraceBuffer ( char __user *pData, int count )
2821 {
2822 #ifdef IP2DEBUG_TRACE
2823 int rc;
2824 int dumpcount;
2825 int chunk;
2826 int *pIndex = (int __user *)pData;
2827
2828 if ( count < (sizeof(int) * 6) ) {
2829 return -EIO;
2830 }
2831 rc = put_user(tracewrap, pIndex );
2832 rc = put_user(TRACEMAX, ++pIndex );
2833 rc = put_user(tracestrip, ++pIndex );
2834 rc = put_user(tracestuff, ++pIndex );
2835 pData += sizeof(int) * 6;
2836 count -= sizeof(int) * 6;
2837
2838 dumpcount = tracestuff - tracestrip;
2839 if ( dumpcount < 0 ) {
2840 dumpcount += TRACEMAX;
2841 }
2842 if ( dumpcount > count ) {
2843 dumpcount = count;
2844 }
2845 chunk = TRACEMAX - tracestrip;
2846 if ( dumpcount > chunk ) {
2847 rc = copy_to_user(pData, &tracebuf[tracestrip],
2848 chunk * sizeof(tracebuf[0]) );
2849 pData += chunk * sizeof(tracebuf[0]);
2850 tracestrip = 0;
2851 chunk = dumpcount - chunk;
2852 } else {
2853 chunk = dumpcount;
2854 }
2855 rc = copy_to_user(pData, &tracebuf[tracestrip],
2856 chunk * sizeof(tracebuf[0]) );
2857 tracestrip += chunk;
2858 tracewrap = 0;
2859
2860 rc = put_user(tracestrip, ++pIndex );
2861 rc = put_user(tracestuff, ++pIndex );
2862
2863 return dumpcount;
2864 #else
2865 return 0;
2866 #endif
2867 }
2868
2869 /******************************************************************************/
2870 /* Function: ip2_ipl_write() */
2871 /* Parameters: */
2872 /* Pointer to file structure */
2873 /* Pointer to data */
2874 /* Number of bytes to write */
2875 /* Returns: Success or failure */
2876 /* */
2877 /* Description: */
2878 /* */
2879 /* */
2880 /******************************************************************************/
2881 static ssize_t
2882 ip2_ipl_write(struct file *pFile, const char __user *pData, size_t count, loff_t *off)
2883 {
2884 #ifdef IP2DEBUG_IPL
2885 printk (KERN_DEBUG "IP2IPL: write %p, %d bytes\n", pData, count );
2886 #endif
2887 return 0;
2888 }
2889
2890 /******************************************************************************/
2891 /* Function: ip2_ipl_ioctl() */
2892 /* Parameters: Pointer to device inode */
2893 /* Pointer to file structure */
2894 /* Command */
2895 /* Argument */
2896 /* Returns: Success or failure */
2897 /* */
2898 /* Description: */
2899 /* */
2900 /* */
2901 /******************************************************************************/
2902 static long
2903 ip2_ipl_ioctl (struct file *pFile, UINT cmd, ULONG arg )
2904 {
2905 unsigned int iplminor = iminor(pFile->f_path.dentry->d_inode);
2906 int rc = 0;
2907 void __user *argp = (void __user *)arg;
2908 ULONG __user *pIndex = argp;
2909 i2eBordStrPtr pB = i2BoardPtrTable[iplminor / 4];
2910 i2ChanStrPtr pCh;
2911
2912 #ifdef IP2DEBUG_IPL
2913 printk (KERN_DEBUG "IP2IPL: ioctl cmd %d, arg %ld\n", cmd, arg );
2914 #endif
2915
2916 mutex_lock(&ip2_mutex);
2917
2918 switch ( iplminor ) {
2919 case 0: // IPL device
2920 rc = -EINVAL;
2921 break;
2922 case 1: // Status dump
2923 case 5:
2924 case 9:
2925 case 13:
2926 switch ( cmd ) {
2927 case 64: /* Driver - ip2stat */
2928 rc = put_user(-1, pIndex++ );
2929 rc = put_user(irq_counter, pIndex++ );
2930 rc = put_user(bh_counter, pIndex++ );
2931 break;
2932
2933 case 65: /* Board - ip2stat */
2934 if ( pB ) {
2935 rc = copy_to_user(argp, pB, sizeof(i2eBordStr));
2936 rc = put_user(inb(pB->i2eStatus),
2937 (ULONG __user *)(arg + (ULONG)(&pB->i2eStatus) - (ULONG)pB ) );
2938 } else {
2939 rc = -ENODEV;
2940 }
2941 break;
2942
2943 default:
2944 if (cmd < IP2_MAX_PORTS) {
2945 pCh = DevTable[cmd];
2946 if ( pCh )
2947 {
2948 rc = copy_to_user(argp, pCh, sizeof(i2ChanStr));
2949 if (rc)
2950 rc = -EFAULT;
2951 } else {
2952 rc = -ENODEV;
2953 }
2954 } else {
2955 rc = -EINVAL;
2956 }
2957 }
2958 break;
2959
2960 case 2: // Ping device
2961 rc = -EINVAL;
2962 break;
2963 case 3: // Trace device
2964 /*
2965 * akpm: This used to write a whole bunch of function addresses
2966 * to userspace, which generated lots of put_user() warnings.
2967 * I killed it all. Just return "success" and don't do
2968 * anything.
2969 */
2970 if (cmd == 1)
2971 rc = 0;
2972 else
2973 rc = -EINVAL;
2974 break;
2975
2976 default:
2977 rc = -ENODEV;
2978 break;
2979 }
2980 mutex_unlock(&ip2_mutex);
2981 return rc;
2982 }
2983
2984 /******************************************************************************/
2985 /* Function: ip2_ipl_open() */
2986 /* Parameters: Pointer to device inode */
2987 /* Pointer to file structure */
2988 /* Returns: Success or failure */
2989 /* */
2990 /* Description: */
2991 /* */
2992 /* */
2993 /******************************************************************************/
2994 static int
2995 ip2_ipl_open( struct inode *pInode, struct file *pFile )
2996 {
2997
2998 #ifdef IP2DEBUG_IPL
2999 printk (KERN_DEBUG "IP2IPL: open\n" );
3000 #endif
3001 return 0;
3002 }
3003
3004 static int
3005 proc_ip2mem_show(struct seq_file *m, void *v)
3006 {
3007 i2eBordStrPtr pB;
3008 i2ChanStrPtr pCh;
3009 PTTY tty;
3010 int i;
3011
3012 #define FMTLINE "%3d: 0x%08x 0x%08x 0%011o 0%011o\n"
3013 #define FMTLIN2 " 0x%04x 0x%04x tx flow 0x%x\n"
3014 #define FMTLIN3 " 0x%04x 0x%04x rc flow\n"
3015
3016 seq_printf(m,"\n");
3017
3018 for( i = 0; i < IP2_MAX_BOARDS; ++i ) {
3019 pB = i2BoardPtrTable[i];
3020 if ( pB ) {
3021 seq_printf(m,"board %d:\n",i);
3022 seq_printf(m,"\tFifo rem: %d mty: %x outM %x\n",
3023 pB->i2eFifoRemains,pB->i2eWaitingForEmptyFifo,pB->i2eOutMailWaiting);
3024 }
3025 }
3026
3027 seq_printf(m,"#: tty flags, port flags, cflags, iflags\n");
3028 for (i=0; i < IP2_MAX_PORTS; i++) {
3029 pCh = DevTable[i];
3030 if (pCh) {
3031 tty = pCh->pTTY;
3032 if (tty && tty->count) {
3033 seq_printf(m,FMTLINE,i,(int)tty->flags,pCh->flags,
3034 tty->termios->c_cflag,tty->termios->c_iflag);
3035
3036 seq_printf(m,FMTLIN2,
3037 pCh->outfl.asof,pCh->outfl.room,pCh->channelNeeds);
3038 seq_printf(m,FMTLIN3,pCh->infl.asof,pCh->infl.room);
3039 }
3040 }
3041 }
3042 return 0;
3043 }
3044
3045 static int proc_ip2mem_open(struct inode *inode, struct file *file)
3046 {
3047 return single_open(file, proc_ip2mem_show, NULL);
3048 }
3049
3050 static const struct file_operations ip2mem_proc_fops = {
3051 .owner = THIS_MODULE,
3052 .open = proc_ip2mem_open,
3053 .read = seq_read,
3054 .llseek = seq_lseek,
3055 .release = single_release,
3056 };
3057
3058 /*
3059 * This is the handler for /proc/tty/driver/ip2
3060 *
3061 * This stretch of code has been largely plagerized from at least three
3062 * different sources including ip2mkdev.c and a couple of other drivers.
3063 * The bugs are all mine. :-) =mhw=
3064 */
3065 static int ip2_proc_show(struct seq_file *m, void *v)
3066 {
3067 int i, j, box;
3068 int boxes = 0;
3069 int ports = 0;
3070 int tports = 0;
3071 i2eBordStrPtr pB;
3072 char *sep;
3073
3074 seq_printf(m, "ip2info: 1.0 driver: %s\n", pcVersion);
3075 seq_printf(m, "Driver: SMajor=%d CMajor=%d IMajor=%d MaxBoards=%d MaxBoxes=%d MaxPorts=%d\n",
3076 IP2_TTY_MAJOR, IP2_CALLOUT_MAJOR, IP2_IPL_MAJOR,
3077 IP2_MAX_BOARDS, ABS_MAX_BOXES, ABS_BIGGEST_BOX);
3078
3079 for( i = 0; i < IP2_MAX_BOARDS; ++i ) {
3080 /* This need to be reset for a board by board count... */
3081 boxes = 0;
3082 pB = i2BoardPtrTable[i];
3083 if( pB ) {
3084 switch( pB->i2ePom.e.porID & ~POR_ID_RESERVED )
3085 {
3086 case POR_ID_FIIEX:
3087 seq_printf(m, "Board %d: EX ports=", i);
3088 sep = "";
3089 for( box = 0; box < ABS_MAX_BOXES; ++box )
3090 {
3091 ports = 0;
3092
3093 if( pB->i2eChannelMap[box] != 0 ) ++boxes;
3094 for( j = 0; j < ABS_BIGGEST_BOX; ++j )
3095 {
3096 if( pB->i2eChannelMap[box] & 1<< j ) {
3097 ++ports;
3098 }
3099 }
3100 seq_printf(m, "%s%d", sep, ports);
3101 sep = ",";
3102 tports += ports;
3103 }
3104 seq_printf(m, " boxes=%d width=%d", boxes, pB->i2eDataWidth16 ? 16 : 8);
3105 break;
3106
3107 case POR_ID_II_4:
3108 seq_printf(m, "Board %d: ISA-4 ports=4 boxes=1", i);
3109 tports = ports = 4;
3110 break;
3111
3112 case POR_ID_II_8:
3113 seq_printf(m, "Board %d: ISA-8-std ports=8 boxes=1", i);
3114 tports = ports = 8;
3115 break;
3116
3117 case POR_ID_II_8R:
3118 seq_printf(m, "Board %d: ISA-8-RJ11 ports=8 boxes=1", i);
3119 tports = ports = 8;
3120 break;
3121
3122 default:
3123 seq_printf(m, "Board %d: unknown", i);
3124 /* Don't try and probe for minor numbers */
3125 tports = ports = 0;
3126 }
3127
3128 } else {
3129 /* Don't try and probe for minor numbers */
3130 seq_printf(m, "Board %d: vacant", i);
3131 tports = ports = 0;
3132 }
3133
3134 if( tports ) {
3135 seq_puts(m, " minors=");
3136 sep = "";
3137 for ( box = 0; box < ABS_MAX_BOXES; ++box )
3138 {
3139 for ( j = 0; j < ABS_BIGGEST_BOX; ++j )
3140 {
3141 if ( pB->i2eChannelMap[box] & (1 << j) )
3142 {
3143 seq_printf(m, "%s%d", sep,
3144 j + ABS_BIGGEST_BOX *
3145 (box+i*ABS_MAX_BOXES));
3146 sep = ",";
3147 }
3148 }
3149 }
3150 }
3151 seq_putc(m, '\n');
3152 }
3153 return 0;
3154 }
3155
3156 static int ip2_proc_open(struct inode *inode, struct file *file)
3157 {
3158 return single_open(file, ip2_proc_show, NULL);
3159 }
3160
3161 static const struct file_operations ip2_proc_fops = {
3162 .owner = THIS_MODULE,
3163 .open = ip2_proc_open,
3164 .read = seq_read,
3165 .llseek = seq_lseek,
3166 .release = single_release,
3167 };
3168
3169 /******************************************************************************/
3170 /* Function: ip2trace() */
3171 /* Parameters: Value to add to trace buffer */
3172 /* Returns: Nothing */
3173 /* */
3174 /* Description: */
3175 /* */
3176 /* */
3177 /******************************************************************************/
3178 #ifdef IP2DEBUG_TRACE
3179 void
3180 ip2trace (unsigned short pn, unsigned char cat, unsigned char label, unsigned long codes, ...)
3181 {
3182 long flags;
3183 unsigned long *pCode = &codes;
3184 union ip2breadcrumb bc;
3185 i2ChanStrPtr pCh;
3186
3187
3188 tracebuf[tracestuff++] = jiffies;
3189 if ( tracestuff == TRACEMAX ) {
3190 tracestuff = 0;
3191 }
3192 if ( tracestuff == tracestrip ) {
3193 if ( ++tracestrip == TRACEMAX ) {
3194 tracestrip = 0;
3195 }
3196 ++tracewrap;
3197 }
3198
3199 bc.hdr.port = 0xff & pn;
3200 bc.hdr.cat = cat;
3201 bc.hdr.codes = (unsigned char)( codes & 0xff );
3202 bc.hdr.label = label;
3203 tracebuf[tracestuff++] = bc.value;
3204
3205 for (;;) {
3206 if ( tracestuff == TRACEMAX ) {
3207 tracestuff = 0;
3208 }
3209 if ( tracestuff == tracestrip ) {
3210 if ( ++tracestrip == TRACEMAX ) {
3211 tracestrip = 0;
3212 }
3213 ++tracewrap;
3214 }
3215
3216 if ( !codes-- )
3217 break;
3218
3219 tracebuf[tracestuff++] = *++pCode;
3220 }
3221 }
3222 #endif
3223
3224
3225 MODULE_LICENSE("GPL");
3226
3227 static struct pci_device_id ip2main_pci_tbl[] __devinitdata __used = {
3228 { PCI_DEVICE(PCI_VENDOR_ID_COMPUTONE, PCI_DEVICE_ID_COMPUTONE_IP2EX) },
3229 { }
3230 };
3231
3232 MODULE_DEVICE_TABLE(pci, ip2main_pci_tbl);
3233
3234 MODULE_FIRMWARE("intelliport2.bin");
ubuntu-bionic-kernel mirror