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