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