projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge master.kernel.org:/pub/scm/linux/kernel/git/davej/cpufreq
[deliverable/linux.git] / drivers / char / ip2 / ip2main.c
1 /*
2 *
3 * (c) 1999 by Computone Corporation
4 *
5 ********************************************************************************
6 *
7 * PACKAGE: Linux tty Device Driver for IntelliPort family of multiport
8 * serial I/O controllers.
9 *
10 * DESCRIPTION: Mainline code for the device driver
11 *
12 *******************************************************************************/
13 // ToDo:
14 //
15 // Fix the immediate DSS_NOW problem.
16 // Work over the channel stats return logic in ip2_ipl_ioctl so they
17 // make sense for all 256 possible channels and so the user space
18 // utilities will compile and work properly.
19 //
20 // Done:
21 //
22 // 1.2.14 /\/\|=mhw=|\/\/
23 // Added bounds checking to ip2_ipl_ioctl to avoid potential terroristic acts.
24 // Changed the definition of ip2trace to be more consistent with kernel style
25 // Thanks to Andreas Dilger <adilger@turbolabs.com> for these updates
26 //
27 // 1.2.13 /\/\|=mhw=|\/\/
28 // DEVFS: Renamed ttf/{n} to tts/F{n} and cuf/{n} to cua/F{n} to conform
29 // to agreed devfs serial device naming convention.
30 //
31 // 1.2.12 /\/\|=mhw=|\/\/
32 // Cleaned up some remove queue cut and paste errors
33 //
34 // 1.2.11 /\/\|=mhw=|\/\/
35 // Clean up potential NULL pointer dereferences
36 // Clean up devfs registration
37 // Add kernel command line parsing for io and irq
38 // Compile defaults for io and irq are now set in ip2.c not ip2.h!
39 // Reworked poll_only hack for explicit parameter setting
40 // You must now EXPLICITLY set poll_only = 1 or set all irqs to 0
41 // Merged ip2_loadmain and old_ip2_init
42 // Converted all instances of interruptible_sleep_on into queue calls
43 // Most of these had no race conditions but better to clean up now
44 //
45 // 1.2.10 /\/\|=mhw=|\/\/
46 // Fixed the bottom half interrupt handler and enabled USE_IQI
47 // to split the interrupt handler into a formal top-half / bottom-half
48 // Fixed timing window on high speed processors that queued messages to
49 // the outbound mail fifo faster than the board could handle.
50 //
51 // 1.2.9
52 // Four box EX was barfing on >128k kmalloc, made structure smaller by
53 // reducing output buffer size
54 //
55 // 1.2.8
56 // Device file system support (MHW)
57 //
58 // 1.2.7
59 // Fixed
60 // Reload of ip2 without unloading ip2main hangs system on cat of /proc/modules
61 //
62 // 1.2.6
63 //Fixes DCD problems
64 // DCD was not reported when CLOCAL was set on call to TIOCMGET
65 //
66 //Enhancements:
67 // TIOCMGET requests and waits for status return
68 // No DSS interrupts enabled except for DCD when needed
69 //
70 // For internal use only
71 //
72 //#define IP2DEBUG_INIT
73 //#define IP2DEBUG_OPEN
74 //#define IP2DEBUG_WRITE
75 //#define IP2DEBUG_READ
76 //#define IP2DEBUG_IOCTL
77 //#define IP2DEBUG_IPL
78
79 //#define IP2DEBUG_TRACE
80 //#define DEBUG_FIFO
81
82 /************/
83 /* Includes */
84 /************/
85
86 #include <linux/ctype.h>
87 #include <linux/string.h>
88 #include <linux/fcntl.h>
89 #include <linux/errno.h>
90 #include <linux/module.h>
91 #include <linux/signal.h>
92 #include <linux/sched.h>
93 #include <linux/timer.h>
94 #include <linux/interrupt.h>
95 #include <linux/pci.h>
96 #include <linux/mm.h>
97 #include <linux/slab.h>
98 #include <linux/major.h>
99 #include <linux/wait.h>
100 #include <linux/device.h>
101
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 termios *);
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(i2eBordStrPtr pB);
193 static irqreturn_t ip2_interrupt(int irq, void *dev_id, struct pt_regs * regs);
194 static void ip2_poll(unsigned long arg);
195 static inline void service_all_boards(void);
196 static void do_input(void *p);
197 static void do_status(void *p);
198
199 static void ip2_wait_until_sent(PTTY,int);
200
201 static void set_params (i2ChanStrPtr, struct termios *);
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 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_class:
783 class_destroy(ip2_class);
784 out_chrdev:
785 unregister_chrdev(IP2_IPL_MAJOR, "ip2");
786 out:
787 return err;
788 }
789
790 EXPORT_SYMBOL(ip2_loadmain);
791
792 /******************************************************************************/
793 /* Function: ip2_init_board() */
794 /* Parameters: Index of board in configuration structure */
795 /* Returns: Success (0) */
796 /* */
797 /* Description: */
798 /* This function initializes the specified board. The loadware is copied to */
799 /* the board, the channel structures are initialized, and the board details */
800 /* are reported on the console. */
801 /******************************************************************************/
802 static void
803 ip2_init_board( int boardnum )
804 {
805 int i;
806 int nports = 0, nboxes = 0;
807 i2ChanStrPtr pCh;
808 i2eBordStrPtr pB = i2BoardPtrTable[boardnum];
809
810 if ( !iiInitialize ( pB ) ) {
811 printk ( KERN_ERR "IP2: Failed to initialize board at 0x%x, error %d\n",
812 pB->i2eBase, pB->i2eError );
813 goto err_initialize;
814 }
815 printk(KERN_INFO "IP2: Board %d: addr=0x%x irq=%d\n", boardnum + 1,
816 ip2config.addr[boardnum], ip2config.irq[boardnum] );
817
818 if (!request_region( ip2config.addr[boardnum], 8, pcName )) {
819 printk(KERN_ERR "IP2: bad addr=0x%x\n", ip2config.addr[boardnum]);
820 goto err_initialize;
821 }
822
823 if ( iiDownloadAll ( pB, (loadHdrStrPtr)Fip_firmware, 1, Fip_firmware_size )
824 != II_DOWN_GOOD ) {
825 printk ( KERN_ERR "IP2: failed to download loadware\n" );
826 goto err_release_region;
827 } else {
828 printk ( KERN_INFO "IP2: fv=%d.%d.%d lv=%d.%d.%d\n",
829 pB->i2ePom.e.porVersion,
830 pB->i2ePom.e.porRevision,
831 pB->i2ePom.e.porSubRev, pB->i2eLVersion,
832 pB->i2eLRevision, pB->i2eLSub );
833 }
834
835 switch ( pB->i2ePom.e.porID & ~POR_ID_RESERVED ) {
836
837 default:
838 printk( KERN_ERR "IP2: Unknown board type, ID = %x\n",
839 pB->i2ePom.e.porID );
840 nports = 0;
841 goto err_release_region;
842 break;
843
844 case POR_ID_II_4: /* IntelliPort-II, ISA-4 (4xRJ45) */
845 printk ( KERN_INFO "IP2: ISA-4\n" );
846 nports = 4;
847 break;
848
849 case POR_ID_II_8: /* IntelliPort-II, 8-port using standard brick. */
850 printk ( KERN_INFO "IP2: ISA-8 std\n" );
851 nports = 8;
852 break;
853
854 case POR_ID_II_8R: /* IntelliPort-II, 8-port using RJ11's (no CTS) */
855 printk ( KERN_INFO "IP2: ISA-8 RJ11\n" );
856 nports = 8;
857 break;
858
859 case POR_ID_FIIEX: /* IntelliPort IIEX */
860 {
861 int portnum = IP2_PORTS_PER_BOARD * boardnum;
862 int box;
863
864 for( box = 0; box < ABS_MAX_BOXES; ++box ) {
865 if ( pB->i2eChannelMap[box] != 0 ) {
866 ++nboxes;
867 }
868 for( i = 0; i < ABS_BIGGEST_BOX; ++i ) {
869 if ( pB->i2eChannelMap[box] & 1<< i ) {
870 ++nports;
871 }
872 }
873 }
874 DevTableMem[boardnum] = pCh =
875 kmalloc( sizeof(i2ChanStr) * nports, GFP_KERNEL );
876 if ( !pCh ) {
877 printk ( KERN_ERR "IP2: (i2_init_channel:) Out of memory.\n");
878 goto err_release_region;
879 }
880 if ( !i2InitChannels( pB, nports, pCh ) ) {
881 printk(KERN_ERR "IP2: i2InitChannels failed: %d\n",pB->i2eError);
882 kfree ( pCh );
883 goto err_release_region;
884 }
885 pB->i2eChannelPtr = &DevTable[portnum];
886 pB->i2eChannelCnt = ABS_MOST_PORTS;
887
888 for( box = 0; box < ABS_MAX_BOXES; ++box, portnum += ABS_BIGGEST_BOX ) {
889 for( i = 0; i < ABS_BIGGEST_BOX; ++i ) {
890 if ( pB->i2eChannelMap[box] & (1 << i) ) {
891 DevTable[portnum + i] = pCh;
892 pCh->port_index = portnum + i;
893 pCh++;
894 }
895 }
896 }
897 printk(KERN_INFO "IP2: EX box=%d ports=%d %d bit\n",
898 nboxes, nports, pB->i2eDataWidth16 ? 16 : 8 );
899 }
900 goto ex_exit;
901 }
902 DevTableMem[boardnum] = pCh =
903 kmalloc ( sizeof (i2ChanStr) * nports, GFP_KERNEL );
904 if ( !pCh ) {
905 printk ( KERN_ERR "IP2: (i2_init_channel:) Out of memory.\n");
906 goto err_release_region;
907 }
908 pB->i2eChannelPtr = pCh;
909 pB->i2eChannelCnt = nports;
910 if ( !i2InitChannels( pB, nports, pCh ) ) {
911 printk(KERN_ERR "IP2: i2InitChannels failed: %d\n",pB->i2eError);
912 kfree ( pCh );
913 goto err_release_region;
914 }
915 pB->i2eChannelPtr = &DevTable[IP2_PORTS_PER_BOARD * boardnum];
916
917 for( i = 0; i < pB->i2eChannelCnt; ++i ) {
918 DevTable[IP2_PORTS_PER_BOARD * boardnum + i] = pCh;
919 pCh->port_index = (IP2_PORTS_PER_BOARD * boardnum) + i;
920 pCh++;
921 }
922 ex_exit:
923 INIT_WORK(&pB->tqueue_interrupt, (void(*)(void*)) ip2_interrupt_bh, pB);
924 return;
925
926 err_release_region:
927 release_region(ip2config.addr[boardnum], 8);
928 err_initialize:
929 kfree ( pB );
930 i2BoardPtrTable[boardnum] = NULL;
931 return;
932 }
933
934 /******************************************************************************/
935 /* Function: find_eisa_board ( int start_slot ) */
936 /* Parameters: First slot to check */
937 /* Returns: Address of EISA IntelliPort II controller */
938 /* */
939 /* Description: */
940 /* This function searches for an EISA IntelliPort controller, starting */
941 /* from the specified slot number. If the motherboard is not identified as an */
942 /* EISA motherboard, or no valid board ID is selected it returns 0. Otherwise */
943 /* it returns the base address of the controller. */
944 /******************************************************************************/
945 static unsigned short
946 find_eisa_board( int start_slot )
947 {
948 int i, j;
949 unsigned int idm = 0;
950 unsigned int idp = 0;
951 unsigned int base = 0;
952 unsigned int value;
953 int setup_address;
954 int setup_irq;
955 int ismine = 0;
956
957 /*
958 * First a check for an EISA motherboard, which we do by comparing the
959 * EISA ID registers for the system board and the first couple of slots.
960 * No slot ID should match the system board ID, but on an ISA or PCI
961 * machine the odds are that an empty bus will return similar values for
962 * each slot.
963 */
964 i = 0x0c80;
965 value = (inb(i) << 24) + (inb(i+1) << 16) + (inb(i+2) << 8) + inb(i+3);
966 for( i = 0x1c80; i <= 0x4c80; i += 0x1000 ) {
967 j = (inb(i)<<24)+(inb(i+1)<<16)+(inb(i+2)<<8)+inb(i+3);
968 if ( value == j )
969 return 0;
970 }
971
972 /*
973 * OK, so we are inclined to believe that this is an EISA machine. Find
974 * an IntelliPort controller.
975 */
976 for( i = start_slot; i < 16; i++ ) {
977 base = i << 12;
978 idm = (inb(base + 0xc80) << 8) | (inb(base + 0xc81) & 0xff);
979 idp = (inb(base + 0xc82) << 8) | (inb(base + 0xc83) & 0xff);
980 ismine = 0;
981 if ( idm == 0x0e8e ) {
982 if ( idp == 0x0281 || idp == 0x0218 ) {
983 ismine = 1;
984 } else if ( idp == 0x0282 || idp == 0x0283 ) {
985 ismine = 3; /* Can do edge-trigger */
986 }
987 if ( ismine ) {
988 Eisa_slot = i;
989 break;
990 }
991 }
992 }
993 if ( !ismine )
994 return 0;
995
996 /* It's some sort of EISA card, but at what address is it configured? */
997
998 setup_address = base + 0xc88;
999 value = inb(base + 0xc86);
1000 setup_irq = (value & 8) ? Valid_Irqs[value & 7] : 0;
1001
1002 if ( (ismine & 2) && !(value & 0x10) ) {
1003 ismine = 1; /* Could be edging, but not */
1004 }
1005
1006 if ( Eisa_irq == 0 ) {
1007 Eisa_irq = setup_irq;
1008 } else if ( Eisa_irq != setup_irq ) {
1009 printk ( KERN_ERR "IP2: EISA irq mismatch between EISA controllers\n" );
1010 }
1011
1012 #ifdef IP2DEBUG_INIT
1013 printk(KERN_DEBUG "Computone EISA board in slot %d, I.D. 0x%x%x, Address 0x%x",
1014 base >> 12, idm, idp, setup_address);
1015 if ( Eisa_irq ) {
1016 printk(KERN_DEBUG ", Interrupt %d %s\n",
1017 setup_irq, (ismine & 2) ? "(edge)" : "(level)");
1018 } else {
1019 printk(KERN_DEBUG ", (polled)\n");
1020 }
1021 #endif
1022 return setup_address;
1023 }
1024
1025 /******************************************************************************/
1026 /* Function: set_irq() */
1027 /* Parameters: index to board in board table */
1028 /* IRQ to use */
1029 /* Returns: Success (0) */
1030 /* */
1031 /* Description: */
1032 /******************************************************************************/
1033 static void
1034 set_irq( int boardnum, int boardIrq )
1035 {
1036 unsigned char tempCommand[16];
1037 i2eBordStrPtr pB = i2BoardPtrTable[boardnum];
1038 unsigned long flags;
1039
1040 /*
1041 * Notify the boards they may generate interrupts. This is done by
1042 * sending an in-line command to channel 0 on each board. This is why
1043 * the channels have to be defined already. For each board, if the
1044 * interrupt has never been defined, we must do so NOW, directly, since
1045 * board will not send flow control or even give an interrupt until this
1046 * is done. If polling we must send 0 as the interrupt parameter.
1047 */
1048
1049 // We will get an interrupt here at the end of this function
1050
1051 iiDisableMailIrq(pB);
1052
1053 /* We build up the entire packet header. */
1054 CHANNEL_OF(tempCommand) = 0;
1055 PTYPE_OF(tempCommand) = PTYPE_INLINE;
1056 CMD_COUNT_OF(tempCommand) = 2;
1057 (CMD_OF(tempCommand))[0] = CMDVALUE_IRQ;
1058 (CMD_OF(tempCommand))[1] = boardIrq;
1059 /*
1060 * Write to FIFO; don't bother to adjust fifo capacity for this, since
1061 * board will respond almost immediately after SendMail hit.
1062 */
1063 WRITE_LOCK_IRQSAVE(&pB->write_fifo_spinlock,flags);
1064 iiWriteBuf(pB, tempCommand, 4);
1065 WRITE_UNLOCK_IRQRESTORE(&pB->write_fifo_spinlock,flags);
1066 pB->i2eUsingIrq = boardIrq;
1067 pB->i2eOutMailWaiting |= MB_OUT_STUFFED;
1068
1069 /* Need to update number of boards before you enable mailbox int */
1070 ++i2nBoards;
1071
1072 CHANNEL_OF(tempCommand) = 0;
1073 PTYPE_OF(tempCommand) = PTYPE_BYPASS;
1074 CMD_COUNT_OF(tempCommand) = 6;
1075 (CMD_OF(tempCommand))[0] = 88; // SILO
1076 (CMD_OF(tempCommand))[1] = 64; // chars
1077 (CMD_OF(tempCommand))[2] = 32; // ms
1078
1079 (CMD_OF(tempCommand))[3] = 28; // MAX_BLOCK
1080 (CMD_OF(tempCommand))[4] = 64; // chars
1081
1082 (CMD_OF(tempCommand))[5] = 87; // HW_TEST
1083 WRITE_LOCK_IRQSAVE(&pB->write_fifo_spinlock,flags);
1084 iiWriteBuf(pB, tempCommand, 8);
1085 WRITE_UNLOCK_IRQRESTORE(&pB->write_fifo_spinlock,flags);
1086
1087 CHANNEL_OF(tempCommand) = 0;
1088 PTYPE_OF(tempCommand) = PTYPE_BYPASS;
1089 CMD_COUNT_OF(tempCommand) = 1;
1090 (CMD_OF(tempCommand))[0] = 84; /* get BOX_IDS */
1091 iiWriteBuf(pB, tempCommand, 3);
1092
1093 #ifdef XXX
1094 // enable heartbeat for test porpoises
1095 CHANNEL_OF(tempCommand) = 0;
1096 PTYPE_OF(tempCommand) = PTYPE_BYPASS;
1097 CMD_COUNT_OF(tempCommand) = 2;
1098 (CMD_OF(tempCommand))[0] = 44; /* get ping */
1099 (CMD_OF(tempCommand))[1] = 200; /* 200 ms */
1100 WRITE_LOCK_IRQSAVE(&pB->write_fifo_spinlock,flags);
1101 iiWriteBuf(pB, tempCommand, 4);
1102 WRITE_UNLOCK_IRQRESTORE(&pB->write_fifo_spinlock,flags);
1103 #endif
1104
1105 iiEnableMailIrq(pB);
1106 iiSendPendingMail(pB);
1107 }
1108
1109 /******************************************************************************/
1110 /* Interrupt Handler Section */
1111 /******************************************************************************/
1112
1113 static inline void
1114 service_all_boards(void)
1115 {
1116 int i;
1117 i2eBordStrPtr pB;
1118
1119 /* Service every board on the list */
1120 for( i = 0; i < IP2_MAX_BOARDS; ++i ) {
1121 pB = i2BoardPtrTable[i];
1122 if ( pB ) {
1123 i2ServiceBoard( pB );
1124 }
1125 }
1126 }
1127
1128
1129 /******************************************************************************/
1130 /* Function: ip2_interrupt_bh(pB) */
1131 /* Parameters: pB - pointer to the board structure */
1132 /* Returns: Nothing */
1133 /* */
1134 /* Description: */
1135 /* Service the board in a bottom half interrupt handler and then */
1136 /* reenable the board's interrupts if it has an IRQ number */
1137 /* */
1138 /******************************************************************************/
1139 static void
1140 ip2_interrupt_bh(i2eBordStrPtr pB)
1141 {
1142 // pB better well be set or we have a problem! We can only get
1143 // here from the IMMEDIATE queue. Here, we process the boards.
1144 // Checking pB doesn't cost much and it saves us from the sanity checkers.
1145
1146 bh_counter++;
1147
1148 if ( pB ) {
1149 i2ServiceBoard( pB );
1150 if( pB->i2eUsingIrq ) {
1151 // Re-enable his interrupts
1152 iiEnableMailIrq(pB);
1153 }
1154 }
1155 }
1156
1157
1158 /******************************************************************************/
1159 /* Function: ip2_interrupt(int irq, void *dev_id, struct pt_regs * regs) */
1160 /* Parameters: irq - interrupt number */
1161 /* pointer to optional device ID structure */
1162 /* pointer to register structure */
1163 /* Returns: Nothing */
1164 /* */
1165 /* Description: */
1166 /* */
1167 /* Our task here is simply to identify each board which needs servicing. */
1168 /* If we are queuing then, queue it to be serviced, and disable its irq */
1169 /* mask otherwise process the board directly. */
1170 /* */
1171 /* We could queue by IRQ but that just complicates things on both ends */
1172 /* with very little gain in performance (how many instructions does */
1173 /* it take to iterate on the immediate queue). */
1174 /* */
1175 /* */
1176 /******************************************************************************/
1177 static irqreturn_t
1178 ip2_interrupt(int irq, void *dev_id, struct pt_regs * regs)
1179 {
1180 int i;
1181 i2eBordStrPtr pB;
1182 int handled = 0;
1183
1184 ip2trace (ITRC_NO_PORT, ITRC_INTR, 99, 1, irq );
1185
1186 /* Service just the boards on the list using this irq */
1187 for( i = 0; i < i2nBoards; ++i ) {
1188 pB = i2BoardPtrTable[i];
1189
1190 // Only process those boards which match our IRQ.
1191 // IRQ = 0 for polled boards, we won't poll "IRQ" boards
1192
1193 if ( pB && (pB->i2eUsingIrq == irq) ) {
1194 handled = 1;
1195 #ifdef USE_IQI
1196
1197 if (NO_MAIL_HERE != ( pB->i2eStartMail = iiGetMail(pB))) {
1198 // Disable his interrupt (will be enabled when serviced)
1199 // This is mostly to protect from reentrancy.
1200 iiDisableMailIrq(pB);
1201
1202 // Park the board on the immediate queue for processing.
1203 schedule_work(&pB->tqueue_interrupt);
1204
1205 // Make sure the immediate queue is flagged to fire.
1206 }
1207 #else
1208 // We are using immediate servicing here. This sucks and can
1209 // cause all sorts of havoc with ppp and others. The failsafe
1210 // check on iiSendPendingMail could also throw a hairball.
1211 i2ServiceBoard( pB );
1212 #endif /* USE_IQI */
1213 }
1214 }
1215
1216 ++irq_counter;
1217
1218 ip2trace (ITRC_NO_PORT, ITRC_INTR, ITRC_RETURN, 0 );
1219 return IRQ_RETVAL(handled);
1220 }
1221
1222 /******************************************************************************/
1223 /* Function: ip2_poll(unsigned long arg) */
1224 /* Parameters: ? */
1225 /* Returns: Nothing */
1226 /* */
1227 /* Description: */
1228 /* This function calls the library routine i2ServiceBoard for each board in */
1229 /* the board table. This is used instead of the interrupt routine when polled */
1230 /* mode is specified. */
1231 /******************************************************************************/
1232 static void
1233 ip2_poll(unsigned long arg)
1234 {
1235 ip2trace (ITRC_NO_PORT, ITRC_INTR, 100, 0 );
1236
1237 TimerOn = 0; // it's the truth but not checked in service
1238
1239 // Just polled boards, IRQ = 0 will hit all non-interrupt boards.
1240 // It will NOT poll boards handled by hard interrupts.
1241 // The issue of queued BH interrups is handled in ip2_interrupt().
1242 ip2_interrupt(0, NULL, NULL);
1243
1244 PollTimer.expires = POLL_TIMEOUT;
1245 add_timer( &PollTimer );
1246 TimerOn = 1;
1247
1248 ip2trace (ITRC_NO_PORT, ITRC_INTR, ITRC_RETURN, 0 );
1249 }
1250
1251 static void do_input(void *p)
1252 {
1253 i2ChanStrPtr pCh = p;
1254 unsigned long flags;
1255
1256 ip2trace(CHANN, ITRC_INPUT, 21, 0 );
1257
1258 // Data input
1259 if ( pCh->pTTY != NULL ) {
1260 READ_LOCK_IRQSAVE(&pCh->Ibuf_spinlock,flags)
1261 if (!pCh->throttled && (pCh->Ibuf_stuff != pCh->Ibuf_strip)) {
1262 READ_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags)
1263 i2Input( pCh );
1264 } else
1265 READ_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags)
1266 } else {
1267 ip2trace(CHANN, ITRC_INPUT, 22, 0 );
1268
1269 i2InputFlush( pCh );
1270 }
1271 }
1272
1273 // code duplicated from n_tty (ldisc)
1274 static inline void isig(int sig, struct tty_struct *tty, int flush)
1275 {
1276 if (tty->pgrp > 0)
1277 kill_pg(tty->pgrp, sig, 1);
1278 if (flush || !L_NOFLSH(tty)) {
1279 if ( tty->ldisc.flush_buffer )
1280 tty->ldisc.flush_buffer(tty);
1281 i2InputFlush( tty->driver_data );
1282 }
1283 }
1284
1285 static void do_status(void *p)
1286 {
1287 i2ChanStrPtr pCh = p;
1288 int status;
1289
1290 status = i2GetStatus( pCh, (I2_BRK|I2_PAR|I2_FRA|I2_OVR) );
1291
1292 ip2trace (CHANN, ITRC_STATUS, 21, 1, status );
1293
1294 if (pCh->pTTY && (status & (I2_BRK|I2_PAR|I2_FRA|I2_OVR)) ) {
1295 if ( (status & I2_BRK) ) {
1296 // code duplicated from n_tty (ldisc)
1297 if (I_IGNBRK(pCh->pTTY))
1298 goto skip_this;
1299 if (I_BRKINT(pCh->pTTY)) {
1300 isig(SIGINT, pCh->pTTY, 1);
1301 goto skip_this;
1302 }
1303 wake_up_interruptible(&pCh->pTTY->read_wait);
1304 }
1305 #ifdef NEVER_HAPPENS_AS_SETUP_XXX
1306 // and can't work because we don't know the_char
1307 // as the_char is reported on a separate path
1308 // The intelligent board does this stuff as setup
1309 {
1310 char brkf = TTY_NORMAL;
1311 unsigned char brkc = '\0';
1312 unsigned char tmp;
1313 if ( (status & I2_BRK) ) {
1314 brkf = TTY_BREAK;
1315 brkc = '\0';
1316 }
1317 else if (status & I2_PAR) {
1318 brkf = TTY_PARITY;
1319 brkc = the_char;
1320 } else if (status & I2_FRA) {
1321 brkf = TTY_FRAME;
1322 brkc = the_char;
1323 } else if (status & I2_OVR) {
1324 brkf = TTY_OVERRUN;
1325 brkc = the_char;
1326 }
1327 tmp = pCh->pTTY->real_raw;
1328 pCh->pTTY->real_raw = 0;
1329 pCh->pTTY->ldisc.receive_buf( pCh->pTTY, &brkc, &brkf, 1 );
1330 pCh->pTTY->real_raw = tmp;
1331 }
1332 #endif /* NEVER_HAPPENS_AS_SETUP_XXX */
1333 }
1334 skip_this:
1335
1336 if ( status & (I2_DDCD | I2_DDSR | I2_DCTS | I2_DRI) ) {
1337 wake_up_interruptible(&pCh->delta_msr_wait);
1338
1339 if ( (pCh->flags & ASYNC_CHECK_CD) && (status & I2_DDCD) ) {
1340 if ( status & I2_DCD ) {
1341 if ( pCh->wopen ) {
1342 wake_up_interruptible ( &pCh->open_wait );
1343 }
1344 } else {
1345 if (pCh->pTTY && (!(pCh->pTTY->termios->c_cflag & CLOCAL)) ) {
1346 tty_hangup( pCh->pTTY );
1347 }
1348 }
1349 }
1350 }
1351
1352 ip2trace (CHANN, ITRC_STATUS, 26, 0 );
1353 }
1354
1355 /******************************************************************************/
1356 /* Device Open/Close/Ioctl Entry Point Section */
1357 /******************************************************************************/
1358
1359 /******************************************************************************/
1360 /* Function: open_sanity_check() */
1361 /* Parameters: Pointer to tty structure */
1362 /* Pointer to file structure */
1363 /* Returns: Success or failure */
1364 /* */
1365 /* Description: */
1366 /* Verifies the structure magic numbers and cross links. */
1367 /******************************************************************************/
1368 #ifdef IP2DEBUG_OPEN
1369 static void
1370 open_sanity_check( i2ChanStrPtr pCh, i2eBordStrPtr pBrd )
1371 {
1372 if ( pBrd->i2eValid != I2E_MAGIC ) {
1373 printk(KERN_ERR "IP2: invalid board structure\n" );
1374 } else if ( pBrd != pCh->pMyBord ) {
1375 printk(KERN_ERR "IP2: board structure pointer mismatch (%p)\n",
1376 pCh->pMyBord );
1377 } else if ( pBrd->i2eChannelCnt < pCh->port_index ) {
1378 printk(KERN_ERR "IP2: bad device index (%d)\n", pCh->port_index );
1379 } else if (&((i2ChanStrPtr)pBrd->i2eChannelPtr)[pCh->port_index] != pCh) {
1380 } else {
1381 printk(KERN_INFO "IP2: all pointers check out!\n" );
1382 }
1383 }
1384 #endif
1385
1386
1387 /******************************************************************************/
1388 /* Function: ip2_open() */
1389 /* Parameters: Pointer to tty structure */
1390 /* Pointer to file structure */
1391 /* Returns: Success or failure */
1392 /* */
1393 /* Description: (MANDATORY) */
1394 /* A successful device open has to run a gauntlet of checks before it */
1395 /* completes. After some sanity checking and pointer setup, the function */
1396 /* blocks until all conditions are satisfied. It then initialises the port to */
1397 /* the default characteristics and returns. */
1398 /******************************************************************************/
1399 static int
1400 ip2_open( PTTY tty, struct file *pFile )
1401 {
1402 wait_queue_t wait;
1403 int rc = 0;
1404 int do_clocal = 0;
1405 i2ChanStrPtr pCh = DevTable[tty->index];
1406
1407 ip2trace (tty->index, ITRC_OPEN, ITRC_ENTER, 0 );
1408
1409 if ( pCh == NULL ) {
1410 return -ENODEV;
1411 }
1412 /* Setup pointer links in device and tty structures */
1413 pCh->pTTY = tty;
1414 tty->driver_data = pCh;
1415
1416 #ifdef IP2DEBUG_OPEN
1417 printk(KERN_DEBUG \
1418 "IP2:open(tty=%p,pFile=%p):dev=%s,ch=%d,idx=%d\n",
1419 tty, pFile, tty->name, pCh->infl.hd.i2sChannel, pCh->port_index);
1420 open_sanity_check ( pCh, pCh->pMyBord );
1421 #endif
1422
1423 i2QueueCommands(PTYPE_INLINE, pCh, 100, 3, CMD_DTRUP,CMD_RTSUP,CMD_DCD_REP);
1424 pCh->dataSetOut |= (I2_DTR | I2_RTS);
1425 serviceOutgoingFifo( pCh->pMyBord );
1426
1427 /* Block here until the port is ready (per serial and istallion) */
1428 /*
1429 * 1. If the port is in the middle of closing wait for the completion
1430 * and then return the appropriate error.
1431 */
1432 init_waitqueue_entry(&wait, current);
1433 add_wait_queue(&pCh->close_wait, &wait);
1434 set_current_state( TASK_INTERRUPTIBLE );
1435
1436 if ( tty_hung_up_p(pFile) || ( pCh->flags & ASYNC_CLOSING )) {
1437 if ( pCh->flags & ASYNC_CLOSING ) {
1438 schedule();
1439 }
1440 if ( tty_hung_up_p(pFile) ) {
1441 set_current_state( TASK_RUNNING );
1442 remove_wait_queue(&pCh->close_wait, &wait);
1443 return( pCh->flags & ASYNC_HUP_NOTIFY ) ? -EAGAIN : -ERESTARTSYS;
1444 }
1445 }
1446 set_current_state( TASK_RUNNING );
1447 remove_wait_queue(&pCh->close_wait, &wait);
1448
1449 /*
1450 * 3. Handle a non-blocking open of a normal port.
1451 */
1452 if ( (pFile->f_flags & O_NONBLOCK) || (tty->flags & (1<<TTY_IO_ERROR) )) {
1453 pCh->flags |= ASYNC_NORMAL_ACTIVE;
1454 goto noblock;
1455 }
1456 /*
1457 * 4. Now loop waiting for the port to be free and carrier present
1458 * (if required).
1459 */
1460 if ( tty->termios->c_cflag & CLOCAL )
1461 do_clocal = 1;
1462
1463 #ifdef IP2DEBUG_OPEN
1464 printk(KERN_DEBUG "OpenBlock: do_clocal = %d\n", do_clocal);
1465 #endif
1466
1467 ++pCh->wopen;
1468
1469 init_waitqueue_entry(&wait, current);
1470 add_wait_queue(&pCh->open_wait, &wait);
1471
1472 for(;;) {
1473 i2QueueCommands(PTYPE_INLINE, pCh, 100, 2, CMD_DTRUP, CMD_RTSUP);
1474 pCh->dataSetOut |= (I2_DTR | I2_RTS);
1475 set_current_state( TASK_INTERRUPTIBLE );
1476 serviceOutgoingFifo( pCh->pMyBord );
1477 if ( tty_hung_up_p(pFile) ) {
1478 set_current_state( TASK_RUNNING );
1479 remove_wait_queue(&pCh->open_wait, &wait);
1480 return ( pCh->flags & ASYNC_HUP_NOTIFY ) ? -EBUSY : -ERESTARTSYS;
1481 }
1482 if (!(pCh->flags & ASYNC_CLOSING) &&
1483 (do_clocal || (pCh->dataSetIn & I2_DCD) )) {
1484 rc = 0;
1485 break;
1486 }
1487
1488 #ifdef IP2DEBUG_OPEN
1489 printk(KERN_DEBUG "ASYNC_CLOSING = %s\n",
1490 (pCh->flags & ASYNC_CLOSING)?"True":"False");
1491 printk(KERN_DEBUG "OpenBlock: waiting for CD or signal\n");
1492 #endif
1493 ip2trace (CHANN, ITRC_OPEN, 3, 2, 0,
1494 (pCh->flags & ASYNC_CLOSING) );
1495 /* check for signal */
1496 if (signal_pending(current)) {
1497 rc = (( pCh->flags & ASYNC_HUP_NOTIFY ) ? -EAGAIN : -ERESTARTSYS);
1498 break;
1499 }
1500 schedule();
1501 }
1502 set_current_state( TASK_RUNNING );
1503 remove_wait_queue(&pCh->open_wait, &wait);
1504
1505 --pCh->wopen; //why count?
1506
1507 ip2trace (CHANN, ITRC_OPEN, 4, 0 );
1508
1509 if (rc != 0 ) {
1510 return rc;
1511 }
1512 pCh->flags |= ASYNC_NORMAL_ACTIVE;
1513
1514 noblock:
1515
1516 /* first open - Assign termios structure to port */
1517 if ( tty->count == 1 ) {
1518 i2QueueCommands(PTYPE_INLINE, pCh, 0, 2, CMD_CTSFL_DSAB, CMD_RTSFL_DSAB);
1519 /* Now we must send the termios settings to the loadware */
1520 set_params( pCh, NULL );
1521 }
1522
1523 /*
1524 * Now set any i2lib options. These may go away if the i2lib code ends
1525 * up rolled into the mainline.
1526 */
1527 pCh->channelOptions |= CO_NBLOCK_WRITE;
1528
1529 #ifdef IP2DEBUG_OPEN
1530 printk (KERN_DEBUG "IP2: open completed\n" );
1531 #endif
1532 serviceOutgoingFifo( pCh->pMyBord );
1533
1534 ip2trace (CHANN, ITRC_OPEN, ITRC_RETURN, 0 );
1535
1536 return 0;
1537 }
1538
1539 /******************************************************************************/
1540 /* Function: ip2_close() */
1541 /* Parameters: Pointer to tty structure */
1542 /* Pointer to file structure */
1543 /* Returns: Nothing */
1544 /* */
1545 /* Description: */
1546 /* */
1547 /* */
1548 /******************************************************************************/
1549 static void
1550 ip2_close( PTTY tty, struct file *pFile )
1551 {
1552 i2ChanStrPtr pCh = tty->driver_data;
1553
1554 if ( !pCh ) {
1555 return;
1556 }
1557
1558 ip2trace (CHANN, ITRC_CLOSE, ITRC_ENTER, 0 );
1559
1560 #ifdef IP2DEBUG_OPEN
1561 printk(KERN_DEBUG "IP2:close %s:\n",tty->name);
1562 #endif
1563
1564 if ( tty_hung_up_p ( pFile ) ) {
1565
1566 ip2trace (CHANN, ITRC_CLOSE, 2, 1, 2 );
1567
1568 return;
1569 }
1570 if ( tty->count > 1 ) { /* not the last close */
1571
1572 ip2trace (CHANN, ITRC_CLOSE, 2, 1, 3 );
1573
1574 return;
1575 }
1576 pCh->flags |= ASYNC_CLOSING; // last close actually
1577
1578 tty->closing = 1;
1579
1580 if (pCh->ClosingWaitTime != ASYNC_CLOSING_WAIT_NONE) {
1581 /*
1582 * Before we drop DTR, make sure the transmitter has completely drained.
1583 * This uses an timeout, after which the close
1584 * completes.
1585 */
1586 ip2_wait_until_sent(tty, pCh->ClosingWaitTime );
1587 }
1588 /*
1589 * At this point we stop accepting input. Here we flush the channel
1590 * input buffer which will allow the board to send up more data. Any
1591 * additional input is tossed at interrupt/poll time.
1592 */
1593 i2InputFlush( pCh );
1594
1595 /* disable DSS reporting */
1596 i2QueueCommands(PTYPE_INLINE, pCh, 100, 4,
1597 CMD_DCD_NREP, CMD_CTS_NREP, CMD_DSR_NREP, CMD_RI_NREP);
1598 if ( !tty || (tty->termios->c_cflag & HUPCL) ) {
1599 i2QueueCommands(PTYPE_INLINE, pCh, 100, 2, CMD_RTSDN, CMD_DTRDN);
1600 pCh->dataSetOut &= ~(I2_DTR | I2_RTS);
1601 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_PAUSE(25));
1602 }
1603
1604 serviceOutgoingFifo ( pCh->pMyBord );
1605
1606 if ( tty->driver->flush_buffer )
1607 tty->driver->flush_buffer(tty);
1608 if ( tty->ldisc.flush_buffer )
1609 tty->ldisc.flush_buffer(tty);
1610 tty->closing = 0;
1611
1612 pCh->pTTY = NULL;
1613
1614 if (pCh->wopen) {
1615 if (pCh->ClosingDelay) {
1616 msleep_interruptible(jiffies_to_msecs(pCh->ClosingDelay));
1617 }
1618 wake_up_interruptible(&pCh->open_wait);
1619 }
1620
1621 pCh->flags &=~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
1622 wake_up_interruptible(&pCh->close_wait);
1623
1624 #ifdef IP2DEBUG_OPEN
1625 DBG_CNT("ip2_close: after wakeups--");
1626 #endif
1627
1628
1629 ip2trace (CHANN, ITRC_CLOSE, ITRC_RETURN, 1, 1 );
1630
1631 return;
1632 }
1633
1634 /******************************************************************************/
1635 /* Function: ip2_hangup() */
1636 /* Parameters: Pointer to tty structure */
1637 /* Returns: Nothing */
1638 /* */
1639 /* Description: */
1640 /* */
1641 /* */
1642 /******************************************************************************/
1643 static void
1644 ip2_hangup ( PTTY tty )
1645 {
1646 i2ChanStrPtr pCh = tty->driver_data;
1647
1648 if( !pCh ) {
1649 return;
1650 }
1651
1652 ip2trace (CHANN, ITRC_HANGUP, ITRC_ENTER, 0 );
1653
1654 ip2_flush_buffer(tty);
1655
1656 /* disable DSS reporting */
1657
1658 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_DCD_NREP);
1659 i2QueueCommands(PTYPE_INLINE, pCh, 0, 2, CMD_CTSFL_DSAB, CMD_RTSFL_DSAB);
1660 if ( (tty->termios->c_cflag & HUPCL) ) {
1661 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 2, CMD_RTSDN, CMD_DTRDN);
1662 pCh->dataSetOut &= ~(I2_DTR | I2_RTS);
1663 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_PAUSE(25));
1664 }
1665 i2QueueCommands(PTYPE_INLINE, pCh, 1, 3,
1666 CMD_CTS_NREP, CMD_DSR_NREP, CMD_RI_NREP);
1667 serviceOutgoingFifo ( pCh->pMyBord );
1668
1669 wake_up_interruptible ( &pCh->delta_msr_wait );
1670
1671 pCh->flags &= ~ASYNC_NORMAL_ACTIVE;
1672 pCh->pTTY = NULL;
1673 wake_up_interruptible ( &pCh->open_wait );
1674
1675 ip2trace (CHANN, ITRC_HANGUP, ITRC_RETURN, 0 );
1676 }
1677
1678 /******************************************************************************/
1679 /******************************************************************************/
1680 /* Device Output Section */
1681 /******************************************************************************/
1682 /******************************************************************************/
1683
1684 /******************************************************************************/
1685 /* Function: ip2_write() */
1686 /* Parameters: Pointer to tty structure */
1687 /* Flag denoting data is in user (1) or kernel (0) space */
1688 /* Pointer to data */
1689 /* Number of bytes to write */
1690 /* Returns: Number of bytes actually written */
1691 /* */
1692 /* Description: (MANDATORY) */
1693 /* */
1694 /* */
1695 /******************************************************************************/
1696 static int
1697 ip2_write( PTTY tty, const unsigned char *pData, int count)
1698 {
1699 i2ChanStrPtr pCh = tty->driver_data;
1700 int bytesSent = 0;
1701 unsigned long flags;
1702
1703 ip2trace (CHANN, ITRC_WRITE, ITRC_ENTER, 2, count, -1 );
1704
1705 /* Flush out any buffered data left over from ip2_putchar() calls. */
1706 ip2_flush_chars( tty );
1707
1708 /* This is the actual move bit. Make sure it does what we need!!!!! */
1709 WRITE_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1710 bytesSent = i2Output( pCh, pData, count, 0 );
1711 WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1712
1713 ip2trace (CHANN, ITRC_WRITE, ITRC_RETURN, 1, bytesSent );
1714
1715 return bytesSent > 0 ? bytesSent : 0;
1716 }
1717
1718 /******************************************************************************/
1719 /* Function: ip2_putchar() */
1720 /* Parameters: Pointer to tty structure */
1721 /* Character to write */
1722 /* Returns: Nothing */
1723 /* */
1724 /* Description: */
1725 /* */
1726 /* */
1727 /******************************************************************************/
1728 static void
1729 ip2_putchar( PTTY tty, unsigned char ch )
1730 {
1731 i2ChanStrPtr pCh = tty->driver_data;
1732 unsigned long flags;
1733
1734 // ip2trace (CHANN, ITRC_PUTC, ITRC_ENTER, 1, ch );
1735
1736 WRITE_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1737 pCh->Pbuf[pCh->Pbuf_stuff++] = ch;
1738 if ( pCh->Pbuf_stuff == sizeof pCh->Pbuf ) {
1739 WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1740 ip2_flush_chars( tty );
1741 } else
1742 WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1743
1744 // ip2trace (CHANN, ITRC_PUTC, ITRC_RETURN, 1, ch );
1745 }
1746
1747 /******************************************************************************/
1748 /* Function: ip2_flush_chars() */
1749 /* Parameters: Pointer to tty structure */
1750 /* Returns: Nothing */
1751 /* */
1752 /* Description: */
1753 /* */
1754 /******************************************************************************/
1755 static void
1756 ip2_flush_chars( PTTY tty )
1757 {
1758 int strip;
1759 i2ChanStrPtr pCh = tty->driver_data;
1760 unsigned long flags;
1761
1762 WRITE_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1763 if ( pCh->Pbuf_stuff ) {
1764
1765 // ip2trace (CHANN, ITRC_PUTC, 10, 1, strip );
1766
1767 //
1768 // We may need to restart i2Output if it does not fullfill this request
1769 //
1770 strip = i2Output( pCh, pCh->Pbuf, pCh->Pbuf_stuff, 0 );
1771 if ( strip != pCh->Pbuf_stuff ) {
1772 memmove( pCh->Pbuf, &pCh->Pbuf[strip], pCh->Pbuf_stuff - strip );
1773 }
1774 pCh->Pbuf_stuff -= strip;
1775 }
1776 WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1777 }
1778
1779 /******************************************************************************/
1780 /* Function: ip2_write_room() */
1781 /* Parameters: Pointer to tty structure */
1782 /* Returns: Number of bytes that the driver can accept */
1783 /* */
1784 /* Description: */
1785 /* */
1786 /******************************************************************************/
1787 static int
1788 ip2_write_room ( PTTY tty )
1789 {
1790 int bytesFree;
1791 i2ChanStrPtr pCh = tty->driver_data;
1792 unsigned long flags;
1793
1794 READ_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1795 bytesFree = i2OutputFree( pCh ) - pCh->Pbuf_stuff;
1796 READ_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1797
1798 ip2trace (CHANN, ITRC_WRITE, 11, 1, bytesFree );
1799
1800 return ((bytesFree > 0) ? bytesFree : 0);
1801 }
1802
1803 /******************************************************************************/
1804 /* Function: ip2_chars_in_buf() */
1805 /* Parameters: Pointer to tty structure */
1806 /* Returns: Number of bytes queued for transmission */
1807 /* */
1808 /* Description: */
1809 /* */
1810 /* */
1811 /******************************************************************************/
1812 static int
1813 ip2_chars_in_buf ( PTTY tty )
1814 {
1815 i2ChanStrPtr pCh = tty->driver_data;
1816 int rc;
1817 unsigned long flags;
1818
1819 ip2trace (CHANN, ITRC_WRITE, 12, 1, pCh->Obuf_char_count + pCh->Pbuf_stuff );
1820
1821 #ifdef IP2DEBUG_WRITE
1822 printk (KERN_DEBUG "IP2: chars in buffer = %d (%d,%d)\n",
1823 pCh->Obuf_char_count + pCh->Pbuf_stuff,
1824 pCh->Obuf_char_count, pCh->Pbuf_stuff );
1825 #endif
1826 READ_LOCK_IRQSAVE(&pCh->Obuf_spinlock,flags);
1827 rc = pCh->Obuf_char_count;
1828 READ_UNLOCK_IRQRESTORE(&pCh->Obuf_spinlock,flags);
1829 READ_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1830 rc += pCh->Pbuf_stuff;
1831 READ_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1832 return rc;
1833 }
1834
1835 /******************************************************************************/
1836 /* Function: ip2_flush_buffer() */
1837 /* Parameters: Pointer to tty structure */
1838 /* Returns: Nothing */
1839 /* */
1840 /* Description: */
1841 /* */
1842 /* */
1843 /******************************************************************************/
1844 static void
1845 ip2_flush_buffer( PTTY tty )
1846 {
1847 i2ChanStrPtr pCh = tty->driver_data;
1848 unsigned long flags;
1849
1850 ip2trace (CHANN, ITRC_FLUSH, ITRC_ENTER, 0 );
1851
1852 #ifdef IP2DEBUG_WRITE
1853 printk (KERN_DEBUG "IP2: flush buffer\n" );
1854 #endif
1855 WRITE_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1856 pCh->Pbuf_stuff = 0;
1857 WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1858 i2FlushOutput( pCh );
1859 ip2_owake(tty);
1860
1861 ip2trace (CHANN, ITRC_FLUSH, ITRC_RETURN, 0 );
1862
1863 }
1864
1865 /******************************************************************************/
1866 /* Function: ip2_wait_until_sent() */
1867 /* Parameters: Pointer to tty structure */
1868 /* Timeout for wait. */
1869 /* Returns: Nothing */
1870 /* */
1871 /* Description: */
1872 /* This function is used in place of the normal tty_wait_until_sent, which */
1873 /* only waits for the driver buffers to be empty (or rather, those buffers */
1874 /* reported by chars_in_buffer) which doesn't work for IP2 due to the */
1875 /* indeterminate number of bytes buffered on the board. */
1876 /******************************************************************************/
1877 static void
1878 ip2_wait_until_sent ( PTTY tty, int timeout )
1879 {
1880 int i = jiffies;
1881 i2ChanStrPtr pCh = tty->driver_data;
1882
1883 tty_wait_until_sent(tty, timeout );
1884 if ( (i = timeout - (jiffies -i)) > 0)
1885 i2DrainOutput( pCh, i );
1886 }
1887
1888 /******************************************************************************/
1889 /******************************************************************************/
1890 /* Device Input Section */
1891 /******************************************************************************/
1892 /******************************************************************************/
1893
1894 /******************************************************************************/
1895 /* Function: ip2_throttle() */
1896 /* Parameters: Pointer to tty structure */
1897 /* Returns: Nothing */
1898 /* */
1899 /* Description: */
1900 /* */
1901 /* */
1902 /******************************************************************************/
1903 static void
1904 ip2_throttle ( PTTY tty )
1905 {
1906 i2ChanStrPtr pCh = tty->driver_data;
1907
1908 #ifdef IP2DEBUG_READ
1909 printk (KERN_DEBUG "IP2: throttle\n" );
1910 #endif
1911 /*
1912 * Signal the poll/interrupt handlers not to forward incoming data to
1913 * the line discipline. This will cause the buffers to fill up in the
1914 * library and thus cause the library routines to send the flow control
1915 * stuff.
1916 */
1917 pCh->throttled = 1;
1918 }
1919
1920 /******************************************************************************/
1921 /* Function: ip2_unthrottle() */
1922 /* Parameters: Pointer to tty structure */
1923 /* Returns: Nothing */
1924 /* */
1925 /* Description: */
1926 /* */
1927 /* */
1928 /******************************************************************************/
1929 static void
1930 ip2_unthrottle ( PTTY tty )
1931 {
1932 i2ChanStrPtr pCh = tty->driver_data;
1933 unsigned long flags;
1934
1935 #ifdef IP2DEBUG_READ
1936 printk (KERN_DEBUG "IP2: unthrottle\n" );
1937 #endif
1938
1939 /* Pass incoming data up to the line discipline again. */
1940 pCh->throttled = 0;
1941 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_RESUME);
1942 serviceOutgoingFifo( pCh->pMyBord );
1943 READ_LOCK_IRQSAVE(&pCh->Ibuf_spinlock,flags)
1944 if ( pCh->Ibuf_stuff != pCh->Ibuf_strip ) {
1945 READ_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags)
1946 #ifdef IP2DEBUG_READ
1947 printk (KERN_DEBUG "i2Input called from unthrottle\n" );
1948 #endif
1949 i2Input( pCh );
1950 } else
1951 READ_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags)
1952 }
1953
1954 static void
1955 ip2_start ( PTTY tty )
1956 {
1957 i2ChanStrPtr pCh = DevTable[tty->index];
1958
1959 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_RESUME);
1960 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_UNSUSPEND);
1961 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_RESUME);
1962 #ifdef IP2DEBUG_WRITE
1963 printk (KERN_DEBUG "IP2: start tx\n" );
1964 #endif
1965 }
1966
1967 static void
1968 ip2_stop ( PTTY tty )
1969 {
1970 i2ChanStrPtr pCh = DevTable[tty->index];
1971
1972 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_SUSPEND);
1973 #ifdef IP2DEBUG_WRITE
1974 printk (KERN_DEBUG "IP2: stop tx\n" );
1975 #endif
1976 }
1977
1978 /******************************************************************************/
1979 /* Device Ioctl Section */
1980 /******************************************************************************/
1981
1982 static int ip2_tiocmget(struct tty_struct *tty, struct file *file)
1983 {
1984 i2ChanStrPtr pCh = DevTable[tty->index];
1985 #ifdef ENABLE_DSSNOW
1986 wait_queue_t wait;
1987 #endif
1988
1989 if (pCh == NULL)
1990 return -ENODEV;
1991
1992 /*
1993 FIXME - the following code is causing a NULL pointer dereference in
1994 2.3.51 in an interrupt handler. It's suppose to prompt the board
1995 to return the DSS signal status immediately. Why doesn't it do
1996 the same thing in 2.2.14?
1997 */
1998
1999 /* This thing is still busted in the 1.2.12 driver on 2.4.x
2000 and even hoses the serial console so the oops can be trapped.
2001 /\/\|=mhw=|\/\/ */
2002
2003 #ifdef ENABLE_DSSNOW
2004 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_DSS_NOW);
2005
2006 init_waitqueue_entry(&wait, current);
2007 add_wait_queue(&pCh->dss_now_wait, &wait);
2008 set_current_state( TASK_INTERRUPTIBLE );
2009
2010 serviceOutgoingFifo( pCh->pMyBord );
2011
2012 schedule();
2013
2014 set_current_state( TASK_RUNNING );
2015 remove_wait_queue(&pCh->dss_now_wait, &wait);
2016
2017 if (signal_pending(current)) {
2018 return -EINTR;
2019 }
2020 #endif
2021 return ((pCh->dataSetOut & I2_RTS) ? TIOCM_RTS : 0)
2022 | ((pCh->dataSetOut & I2_DTR) ? TIOCM_DTR : 0)
2023 | ((pCh->dataSetIn & I2_DCD) ? TIOCM_CAR : 0)
2024 | ((pCh->dataSetIn & I2_RI) ? TIOCM_RNG : 0)
2025 | ((pCh->dataSetIn & I2_DSR) ? TIOCM_DSR : 0)
2026 | ((pCh->dataSetIn & I2_CTS) ? TIOCM_CTS : 0);
2027 }
2028
2029 static int ip2_tiocmset(struct tty_struct *tty, struct file *file,
2030 unsigned int set, unsigned int clear)
2031 {
2032 i2ChanStrPtr pCh = DevTable[tty->index];
2033
2034 if (pCh == NULL)
2035 return -ENODEV;
2036
2037 if (set & TIOCM_RTS) {
2038 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_RTSUP);
2039 pCh->dataSetOut |= I2_RTS;
2040 }
2041 if (set & TIOCM_DTR) {
2042 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DTRUP);
2043 pCh->dataSetOut |= I2_DTR;
2044 }
2045
2046 if (clear & TIOCM_RTS) {
2047 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_RTSDN);
2048 pCh->dataSetOut &= ~I2_RTS;
2049 }
2050 if (clear & TIOCM_DTR) {
2051 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DTRDN);
2052 pCh->dataSetOut &= ~I2_DTR;
2053 }
2054 serviceOutgoingFifo( pCh->pMyBord );
2055 return 0;
2056 }
2057
2058 /******************************************************************************/
2059 /* Function: ip2_ioctl() */
2060 /* Parameters: Pointer to tty structure */
2061 /* Pointer to file structure */
2062 /* Command */
2063 /* Argument */
2064 /* Returns: Success or failure */
2065 /* */
2066 /* Description: */
2067 /* */
2068 /* */
2069 /******************************************************************************/
2070 static int
2071 ip2_ioctl ( PTTY tty, struct file *pFile, UINT cmd, ULONG arg )
2072 {
2073 wait_queue_t wait;
2074 i2ChanStrPtr pCh = DevTable[tty->index];
2075 i2eBordStrPtr pB;
2076 struct async_icount cprev, cnow; /* kernel counter temps */
2077 struct serial_icounter_struct __user *p_cuser;
2078 int rc = 0;
2079 unsigned long flags;
2080 void __user *argp = (void __user *)arg;
2081
2082 if ( pCh == NULL )
2083 return -ENODEV;
2084
2085 pB = pCh->pMyBord;
2086
2087 ip2trace (CHANN, ITRC_IOCTL, ITRC_ENTER, 2, cmd, arg );
2088
2089 #ifdef IP2DEBUG_IOCTL
2090 printk(KERN_DEBUG "IP2: ioctl cmd (%x), arg (%lx)\n", cmd, arg );
2091 #endif
2092
2093 switch(cmd) {
2094 case TIOCGSERIAL:
2095
2096 ip2trace (CHANN, ITRC_IOCTL, 2, 1, rc );
2097
2098 rc = get_serial_info(pCh, argp);
2099 if (rc)
2100 return rc;
2101 break;
2102
2103 case TIOCSSERIAL:
2104
2105 ip2trace (CHANN, ITRC_IOCTL, 3, 1, rc );
2106
2107 rc = set_serial_info(pCh, argp);
2108 if (rc)
2109 return rc;
2110 break;
2111
2112 case TCXONC:
2113 rc = tty_check_change(tty);
2114 if (rc)
2115 return rc;
2116 switch (arg) {
2117 case TCOOFF:
2118 //return -ENOIOCTLCMD;
2119 break;
2120 case TCOON:
2121 //return -ENOIOCTLCMD;
2122 break;
2123 case TCIOFF:
2124 if (STOP_CHAR(tty) != __DISABLED_CHAR) {
2125 i2QueueCommands( PTYPE_BYPASS, pCh, 100, 1,
2126 CMD_XMIT_NOW(STOP_CHAR(tty)));
2127 }
2128 break;
2129 case TCION:
2130 if (START_CHAR(tty) != __DISABLED_CHAR) {
2131 i2QueueCommands( PTYPE_BYPASS, pCh, 100, 1,
2132 CMD_XMIT_NOW(START_CHAR(tty)));
2133 }
2134 break;
2135 default:
2136 return -EINVAL;
2137 }
2138 return 0;
2139
2140 case TCSBRK: /* SVID version: non-zero arg --> no break */
2141 rc = tty_check_change(tty);
2142
2143 ip2trace (CHANN, ITRC_IOCTL, 4, 1, rc );
2144
2145 if (!rc) {
2146 ip2_wait_until_sent(tty,0);
2147 if (!arg) {
2148 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_SEND_BRK(250));
2149 serviceOutgoingFifo( pCh->pMyBord );
2150 }
2151 }
2152 break;
2153
2154 case TCSBRKP: /* support for POSIX tcsendbreak() */
2155 rc = tty_check_change(tty);
2156
2157 ip2trace (CHANN, ITRC_IOCTL, 5, 1, rc );
2158
2159 if (!rc) {
2160 ip2_wait_until_sent(tty,0);
2161 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1,
2162 CMD_SEND_BRK(arg ? arg*100 : 250));
2163 serviceOutgoingFifo ( pCh->pMyBord );
2164 }
2165 break;
2166
2167 case TIOCGSOFTCAR:
2168
2169 ip2trace (CHANN, ITRC_IOCTL, 6, 1, rc );
2170
2171 rc = put_user(C_CLOCAL(tty) ? 1 : 0, (unsigned long __user *)argp);
2172 if (rc)
2173 return rc;
2174 break;
2175
2176 case TIOCSSOFTCAR:
2177
2178 ip2trace (CHANN, ITRC_IOCTL, 7, 1, rc );
2179
2180 rc = get_user(arg,(unsigned long __user *) argp);
2181 if (rc)
2182 return rc;
2183 tty->termios->c_cflag = ((tty->termios->c_cflag & ~CLOCAL)
2184 | (arg ? CLOCAL : 0));
2185
2186 break;
2187
2188 /*
2189 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change - mask
2190 * passed in arg for lines of interest (use |'ed TIOCM_RNG/DSR/CD/CTS
2191 * for masking). Caller should use TIOCGICOUNT to see which one it was
2192 */
2193 case TIOCMIWAIT:
2194 WRITE_LOCK_IRQSAVE(&pB->read_fifo_spinlock, flags);
2195 cprev = pCh->icount; /* note the counters on entry */
2196 WRITE_UNLOCK_IRQRESTORE(&pB->read_fifo_spinlock, flags);
2197 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 4,
2198 CMD_DCD_REP, CMD_CTS_REP, CMD_DSR_REP, CMD_RI_REP);
2199 init_waitqueue_entry(&wait, current);
2200 add_wait_queue(&pCh->delta_msr_wait, &wait);
2201 set_current_state( TASK_INTERRUPTIBLE );
2202
2203 serviceOutgoingFifo( pCh->pMyBord );
2204 for(;;) {
2205 ip2trace (CHANN, ITRC_IOCTL, 10, 0 );
2206
2207 schedule();
2208
2209 ip2trace (CHANN, ITRC_IOCTL, 11, 0 );
2210
2211 /* see if a signal did it */
2212 if (signal_pending(current)) {
2213 rc = -ERESTARTSYS;
2214 break;
2215 }
2216 WRITE_LOCK_IRQSAVE(&pB->read_fifo_spinlock, flags);
2217 cnow = pCh->icount; /* atomic copy */
2218 WRITE_UNLOCK_IRQRESTORE(&pB->read_fifo_spinlock, flags);
2219 if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
2220 cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) {
2221 rc = -EIO; /* no change => rc */
2222 break;
2223 }
2224 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
2225 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
2226 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
2227 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)) ) {
2228 rc = 0;
2229 break;
2230 }
2231 cprev = cnow;
2232 }
2233 set_current_state( TASK_RUNNING );
2234 remove_wait_queue(&pCh->delta_msr_wait, &wait);
2235
2236 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 3,
2237 CMD_CTS_NREP, CMD_DSR_NREP, CMD_RI_NREP);
2238 if ( ! (pCh->flags & ASYNC_CHECK_CD)) {
2239 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_DCD_NREP);
2240 }
2241 serviceOutgoingFifo( pCh->pMyBord );
2242 return rc;
2243 break;
2244
2245 /*
2246 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
2247 * Return: write counters to the user passed counter struct
2248 * NB: both 1->0 and 0->1 transitions are counted except for RI where
2249 * only 0->1 is counted. The controller is quite capable of counting
2250 * both, but this done to preserve compatibility with the standard
2251 * serial driver.
2252 */
2253 case TIOCGICOUNT:
2254 ip2trace (CHANN, ITRC_IOCTL, 11, 1, rc );
2255
2256 WRITE_LOCK_IRQSAVE(&pB->read_fifo_spinlock, flags);
2257 cnow = pCh->icount;
2258 WRITE_UNLOCK_IRQRESTORE(&pB->read_fifo_spinlock, flags);
2259 p_cuser = argp;
2260 rc = put_user(cnow.cts, &p_cuser->cts);
2261 rc = put_user(cnow.dsr, &p_cuser->dsr);
2262 rc = put_user(cnow.rng, &p_cuser->rng);
2263 rc = put_user(cnow.dcd, &p_cuser->dcd);
2264 rc = put_user(cnow.rx, &p_cuser->rx);
2265 rc = put_user(cnow.tx, &p_cuser->tx);
2266 rc = put_user(cnow.frame, &p_cuser->frame);
2267 rc = put_user(cnow.overrun, &p_cuser->overrun);
2268 rc = put_user(cnow.parity, &p_cuser->parity);
2269 rc = put_user(cnow.brk, &p_cuser->brk);
2270 rc = put_user(cnow.buf_overrun, &p_cuser->buf_overrun);
2271 break;
2272
2273 /*
2274 * The rest are not supported by this driver. By returning -ENOIOCTLCMD they
2275 * will be passed to the line discipline for it to handle.
2276 */
2277 case TIOCSERCONFIG:
2278 case TIOCSERGWILD:
2279 case TIOCSERGETLSR:
2280 case TIOCSERSWILD:
2281 case TIOCSERGSTRUCT:
2282 case TIOCSERGETMULTI:
2283 case TIOCSERSETMULTI:
2284
2285 default:
2286 ip2trace (CHANN, ITRC_IOCTL, 12, 0 );
2287
2288 rc = -ENOIOCTLCMD;
2289 break;
2290 }
2291
2292 ip2trace (CHANN, ITRC_IOCTL, ITRC_RETURN, 0 );
2293
2294 return rc;
2295 }
2296
2297 /******************************************************************************/
2298 /* Function: GetSerialInfo() */
2299 /* Parameters: Pointer to channel structure */
2300 /* Pointer to old termios structure */
2301 /* Returns: Nothing */
2302 /* */
2303 /* Description: */
2304 /* This is to support the setserial command, and requires processing of the */
2305 /* standard Linux serial structure. */
2306 /******************************************************************************/
2307 static int
2308 get_serial_info ( i2ChanStrPtr pCh, struct serial_struct __user *retinfo )
2309 {
2310 struct serial_struct tmp;
2311
2312 memset ( &tmp, 0, sizeof(tmp) );
2313 tmp.type = pCh->pMyBord->channelBtypes.bid_value[(pCh->port_index & (IP2_PORTS_PER_BOARD-1))/16];
2314 if (BID_HAS_654(tmp.type)) {
2315 tmp.type = PORT_16650;
2316 } else {
2317 tmp.type = PORT_CIRRUS;
2318 }
2319 tmp.line = pCh->port_index;
2320 tmp.port = pCh->pMyBord->i2eBase;
2321 tmp.irq = ip2config.irq[pCh->port_index/64];
2322 tmp.flags = pCh->flags;
2323 tmp.baud_base = pCh->BaudBase;
2324 tmp.close_delay = pCh->ClosingDelay;
2325 tmp.closing_wait = pCh->ClosingWaitTime;
2326 tmp.custom_divisor = pCh->BaudDivisor;
2327 return copy_to_user(retinfo,&tmp,sizeof(*retinfo));
2328 }
2329
2330 /******************************************************************************/
2331 /* Function: SetSerialInfo() */
2332 /* Parameters: Pointer to channel structure */
2333 /* Pointer to old termios structure */
2334 /* Returns: Nothing */
2335 /* */
2336 /* Description: */
2337 /* This function provides support for setserial, which uses the TIOCSSERIAL */
2338 /* ioctl. Not all setserial parameters are relevant. If the user attempts to */
2339 /* change the IRQ, address or type of the port the ioctl fails. */
2340 /******************************************************************************/
2341 static int
2342 set_serial_info( i2ChanStrPtr pCh, struct serial_struct __user *new_info )
2343 {
2344 struct serial_struct ns;
2345 int old_flags, old_baud_divisor;
2346
2347 if (copy_from_user(&ns, new_info, sizeof (ns)))
2348 return -EFAULT;
2349
2350 /*
2351 * We don't allow setserial to change IRQ, board address, type or baud
2352 * base. Also line nunber as such is meaningless but we use it for our
2353 * array index so it is fixed also.
2354 */
2355 if ( (ns.irq != ip2config.irq[pCh->port_index])
2356 || ((int) ns.port != ((int) (pCh->pMyBord->i2eBase)))
2357 || (ns.baud_base != pCh->BaudBase)
2358 || (ns.line != pCh->port_index) ) {
2359 return -EINVAL;
2360 }
2361
2362 old_flags = pCh->flags;
2363 old_baud_divisor = pCh->BaudDivisor;
2364
2365 if ( !capable(CAP_SYS_ADMIN) ) {
2366 if ( ( ns.close_delay != pCh->ClosingDelay ) ||
2367 ( (ns.flags & ~ASYNC_USR_MASK) !=
2368 (pCh->flags & ~ASYNC_USR_MASK) ) ) {
2369 return -EPERM;
2370 }
2371
2372 pCh->flags = (pCh->flags & ~ASYNC_USR_MASK) |
2373 (ns.flags & ASYNC_USR_MASK);
2374 pCh->BaudDivisor = ns.custom_divisor;
2375 } else {
2376 pCh->flags = (pCh->flags & ~ASYNC_FLAGS) |
2377 (ns.flags & ASYNC_FLAGS);
2378 pCh->BaudDivisor = ns.custom_divisor;
2379 pCh->ClosingDelay = ns.close_delay * HZ/100;
2380 pCh->ClosingWaitTime = ns.closing_wait * HZ/100;
2381 }
2382
2383 if ( ( (old_flags & ASYNC_SPD_MASK) != (pCh->flags & ASYNC_SPD_MASK) )
2384 || (old_baud_divisor != pCh->BaudDivisor) ) {
2385 // Invalidate speed and reset parameters
2386 set_params( pCh, NULL );
2387 }
2388
2389 return 0;
2390 }
2391
2392 /******************************************************************************/
2393 /* Function: ip2_set_termios() */
2394 /* Parameters: Pointer to tty structure */
2395 /* Pointer to old termios structure */
2396 /* Returns: Nothing */
2397 /* */
2398 /* Description: */
2399 /* */
2400 /* */
2401 /******************************************************************************/
2402 static void
2403 ip2_set_termios( PTTY tty, struct termios *old_termios )
2404 {
2405 i2ChanStrPtr pCh = (i2ChanStrPtr)tty->driver_data;
2406
2407 #ifdef IP2DEBUG_IOCTL
2408 printk (KERN_DEBUG "IP2: set termios %p\n", old_termios );
2409 #endif
2410
2411 set_params( pCh, old_termios );
2412 }
2413
2414 /******************************************************************************/
2415 /* Function: ip2_set_line_discipline() */
2416 /* Parameters: Pointer to tty structure */
2417 /* Returns: Nothing */
2418 /* */
2419 /* Description: Does nothing */
2420 /* */
2421 /* */
2422 /******************************************************************************/
2423 static void
2424 ip2_set_line_discipline ( PTTY tty )
2425 {
2426 #ifdef IP2DEBUG_IOCTL
2427 printk (KERN_DEBUG "IP2: set line discipline\n" );
2428 #endif
2429
2430 ip2trace (((i2ChanStrPtr)tty->driver_data)->port_index, ITRC_IOCTL, 16, 0 );
2431
2432 }
2433
2434 /******************************************************************************/
2435 /* Function: SetLine Characteristics() */
2436 /* Parameters: Pointer to channel structure */
2437 /* Returns: Nothing */
2438 /* */
2439 /* Description: */
2440 /* This routine is called to update the channel structure with the new line */
2441 /* characteristics, and send the appropriate commands to the board when they */
2442 /* change. */
2443 /******************************************************************************/
2444 static void
2445 set_params( i2ChanStrPtr pCh, struct termios *o_tios )
2446 {
2447 tcflag_t cflag, iflag, lflag;
2448 char stop_char, start_char;
2449 struct termios dummy;
2450
2451 lflag = pCh->pTTY->termios->c_lflag;
2452 cflag = pCh->pTTY->termios->c_cflag;
2453 iflag = pCh->pTTY->termios->c_iflag;
2454
2455 if (o_tios == NULL) {
2456 dummy.c_lflag = ~lflag;
2457 dummy.c_cflag = ~cflag;
2458 dummy.c_iflag = ~iflag;
2459 o_tios = &dummy;
2460 }
2461
2462 {
2463 switch ( cflag & CBAUD ) {
2464 case B0:
2465 i2QueueCommands( PTYPE_BYPASS, pCh, 100, 2, CMD_RTSDN, CMD_DTRDN);
2466 pCh->dataSetOut &= ~(I2_DTR | I2_RTS);
2467 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_PAUSE(25));
2468 pCh->pTTY->termios->c_cflag |= (CBAUD & o_tios->c_cflag);
2469 goto service_it;
2470 break;
2471 case B38400:
2472 /*
2473 * This is the speed that is overloaded with all the other high
2474 * speeds, depending upon the flag settings.
2475 */
2476 if ( ( pCh->flags & ASYNC_SPD_MASK ) == ASYNC_SPD_HI ) {
2477 pCh->speed = CBR_57600;
2478 } else if ( (pCh->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI ) {
2479 pCh->speed = CBR_115200;
2480 } else if ( (pCh->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST ) {
2481 pCh->speed = CBR_C1;
2482 } else {
2483 pCh->speed = CBR_38400;
2484 }
2485 break;
2486 case B50: pCh->speed = CBR_50; break;
2487 case B75: pCh->speed = CBR_75; break;
2488 case B110: pCh->speed = CBR_110; break;
2489 case B134: pCh->speed = CBR_134; break;
2490 case B150: pCh->speed = CBR_150; break;
2491 case B200: pCh->speed = CBR_200; break;
2492 case B300: pCh->speed = CBR_300; break;
2493 case B600: pCh->speed = CBR_600; break;
2494 case B1200: pCh->speed = CBR_1200; break;
2495 case B1800: pCh->speed = CBR_1800; break;
2496 case B2400: pCh->speed = CBR_2400; break;
2497 case B4800: pCh->speed = CBR_4800; break;
2498 case B9600: pCh->speed = CBR_9600; break;
2499 case B19200: pCh->speed = CBR_19200; break;
2500 case B57600: pCh->speed = CBR_57600; break;
2501 case B115200: pCh->speed = CBR_115200; break;
2502 case B153600: pCh->speed = CBR_153600; break;
2503 case B230400: pCh->speed = CBR_230400; break;
2504 case B307200: pCh->speed = CBR_307200; break;
2505 case B460800: pCh->speed = CBR_460800; break;
2506 case B921600: pCh->speed = CBR_921600; break;
2507 default: pCh->speed = CBR_9600; break;
2508 }
2509 if ( pCh->speed == CBR_C1 ) {
2510 // Process the custom speed parameters.
2511 int bps = pCh->BaudBase / pCh->BaudDivisor;
2512 if ( bps == 921600 ) {
2513 pCh->speed = CBR_921600;
2514 } else {
2515 bps = bps/10;
2516 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_BAUD_DEF1(bps) );
2517 }
2518 }
2519 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_SETBAUD(pCh->speed));
2520
2521 i2QueueCommands ( PTYPE_INLINE, pCh, 100, 2, CMD_DTRUP, CMD_RTSUP);
2522 pCh->dataSetOut |= (I2_DTR | I2_RTS);
2523 }
2524 if ( (CSTOPB & cflag) ^ (CSTOPB & o_tios->c_cflag))
2525 {
2526 i2QueueCommands ( PTYPE_INLINE, pCh, 100, 1,
2527 CMD_SETSTOP( ( cflag & CSTOPB ) ? CST_2 : CST_1));
2528 }
2529 if (((PARENB|PARODD) & cflag) ^ ((PARENB|PARODD) & o_tios->c_cflag))
2530 {
2531 i2QueueCommands ( PTYPE_INLINE, pCh, 100, 1,
2532 CMD_SETPAR(
2533 (cflag & PARENB ? (cflag & PARODD ? CSP_OD : CSP_EV) : CSP_NP)
2534 )
2535 );
2536 }
2537 /* byte size and parity */
2538 if ( (CSIZE & cflag)^(CSIZE & o_tios->c_cflag))
2539 {
2540 int datasize;
2541 switch ( cflag & CSIZE ) {
2542 case CS5: datasize = CSZ_5; break;
2543 case CS6: datasize = CSZ_6; break;
2544 case CS7: datasize = CSZ_7; break;
2545 case CS8: datasize = CSZ_8; break;
2546 default: datasize = CSZ_5; break; /* as per serial.c */
2547 }
2548 i2QueueCommands ( PTYPE_INLINE, pCh, 100, 1, CMD_SETBITS(datasize) );
2549 }
2550 /* Process CTS flow control flag setting */
2551 if ( (cflag & CRTSCTS) ) {
2552 i2QueueCommands(PTYPE_INLINE, pCh, 100,
2553 2, CMD_CTSFL_ENAB, CMD_RTSFL_ENAB);
2554 } else {
2555 i2QueueCommands(PTYPE_INLINE, pCh, 100,
2556 2, CMD_CTSFL_DSAB, CMD_RTSFL_DSAB);
2557 }
2558 //
2559 // Process XON/XOFF flow control flags settings
2560 //
2561 stop_char = STOP_CHAR(pCh->pTTY);
2562 start_char = START_CHAR(pCh->pTTY);
2563
2564 //////////// can't be \000
2565 if (stop_char == __DISABLED_CHAR )
2566 {
2567 stop_char = ~__DISABLED_CHAR;
2568 }
2569 if (start_char == __DISABLED_CHAR )
2570 {
2571 start_char = ~__DISABLED_CHAR;
2572 }
2573 /////////////////////////////////
2574
2575 if ( o_tios->c_cc[VSTART] != start_char )
2576 {
2577 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_DEF_IXON(start_char));
2578 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DEF_OXON(start_char));
2579 }
2580 if ( o_tios->c_cc[VSTOP] != stop_char )
2581 {
2582 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_DEF_IXOFF(stop_char));
2583 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DEF_OXOFF(stop_char));
2584 }
2585 if (stop_char == __DISABLED_CHAR )
2586 {
2587 stop_char = ~__DISABLED_CHAR; //TEST123
2588 goto no_xoff;
2589 }
2590 if ((iflag & (IXOFF))^(o_tios->c_iflag & (IXOFF)))
2591 {
2592 if ( iflag & IXOFF ) { // Enable XOFF output flow control
2593 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_OXON_OPT(COX_XON));
2594 } else { // Disable XOFF output flow control
2595 no_xoff:
2596 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_OXON_OPT(COX_NONE));
2597 }
2598 }
2599 if (start_char == __DISABLED_CHAR )
2600 {
2601 goto no_xon;
2602 }
2603 if ((iflag & (IXON|IXANY)) ^ (o_tios->c_iflag & (IXON|IXANY)))
2604 {
2605 if ( iflag & IXON ) {
2606 if ( iflag & IXANY ) { // Enable XON/XANY output flow control
2607 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_IXON_OPT(CIX_XANY));
2608 } else { // Enable XON output flow control
2609 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_IXON_OPT(CIX_XON));
2610 }
2611 } else { // Disable XON output flow control
2612 no_xon:
2613 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_IXON_OPT(CIX_NONE));
2614 }
2615 }
2616 if ( (iflag & ISTRIP) ^ ( o_tios->c_iflag & (ISTRIP)) )
2617 {
2618 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1,
2619 CMD_ISTRIP_OPT((iflag & ISTRIP ? 1 : 0)));
2620 }
2621 if ( (iflag & INPCK) ^ ( o_tios->c_iflag & (INPCK)) )
2622 {
2623 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1,
2624 CMD_PARCHK((iflag & INPCK) ? CPK_ENAB : CPK_DSAB));
2625 }
2626
2627 if ( (iflag & (IGNBRK|PARMRK|BRKINT|IGNPAR))
2628 ^ ( o_tios->c_iflag & (IGNBRK|PARMRK|BRKINT|IGNPAR)) )
2629 {
2630 char brkrpt = 0;
2631 char parrpt = 0;
2632
2633 if ( iflag & IGNBRK ) { /* Ignore breaks altogether */
2634 /* Ignore breaks altogether */
2635 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_BRK_NREP);
2636 } else {
2637 if ( iflag & BRKINT ) {
2638 if ( iflag & PARMRK ) {
2639 brkrpt = 0x0a; // exception an inline triple
2640 } else {
2641 brkrpt = 0x1a; // exception and NULL
2642 }
2643 brkrpt |= 0x04; // flush input
2644 } else {
2645 if ( iflag & PARMRK ) {
2646 brkrpt = 0x0b; //POSIX triple \0377 \0 \0
2647 } else {
2648 brkrpt = 0x01; // Null only
2649 }
2650 }
2651 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_BRK_REP(brkrpt));
2652 }
2653
2654 if (iflag & IGNPAR) {
2655 parrpt = 0x20;
2656 /* would be 2 for not cirrus bug */
2657 /* would be 0x20 cept for cirrus bug */
2658 } else {
2659 if ( iflag & PARMRK ) {
2660 /*
2661 * Replace error characters with 3-byte sequence (\0377,\0,char)
2662 */
2663 parrpt = 0x04 ;
2664 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_ISTRIP_OPT((char)0));
2665 } else {
2666 parrpt = 0x03;
2667 }
2668 }
2669 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_SET_ERROR(parrpt));
2670 }
2671 if (cflag & CLOCAL) {
2672 // Status reporting fails for DCD if this is off
2673 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DCD_NREP);
2674 pCh->flags &= ~ASYNC_CHECK_CD;
2675 } else {
2676 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DCD_REP);
2677 pCh->flags |= ASYNC_CHECK_CD;
2678 }
2679
2680 service_it:
2681 i2DrainOutput( pCh, 100 );
2682 }
2683
2684 /******************************************************************************/
2685 /* IPL Device Section */
2686 /******************************************************************************/
2687
2688 /******************************************************************************/
2689 /* Function: ip2_ipl_read() */
2690 /* Parameters: Pointer to device inode */
2691 /* Pointer to file structure */
2692 /* Pointer to data */
2693 /* Number of bytes to read */
2694 /* Returns: Success or failure */
2695 /* */
2696 /* Description: Ugly */
2697 /* */
2698 /* */
2699 /******************************************************************************/
2700
2701 static
2702 ssize_t
2703 ip2_ipl_read(struct file *pFile, char __user *pData, size_t count, loff_t *off )
2704 {
2705 unsigned int minor = iminor(pFile->f_dentry->d_inode);
2706 int rc = 0;
2707
2708 #ifdef IP2DEBUG_IPL
2709 printk (KERN_DEBUG "IP2IPL: read %p, %d bytes\n", pData, count );
2710 #endif
2711
2712 switch( minor ) {
2713 case 0: // IPL device
2714 rc = -EINVAL;
2715 break;
2716 case 1: // Status dump
2717 rc = -EINVAL;
2718 break;
2719 case 2: // Ping device
2720 rc = -EINVAL;
2721 break;
2722 case 3: // Trace device
2723 rc = DumpTraceBuffer ( pData, count );
2724 break;
2725 case 4: // Trace device
2726 rc = DumpFifoBuffer ( pData, count );
2727 break;
2728 default:
2729 rc = -ENODEV;
2730 break;
2731 }
2732 return rc;
2733 }
2734
2735 static int
2736 DumpFifoBuffer ( char __user *pData, int count )
2737 {
2738 #ifdef DEBUG_FIFO
2739 int rc;
2740 rc = copy_to_user(pData, DBGBuf, count);
2741
2742 printk(KERN_DEBUG "Last index %d\n", I );
2743
2744 return count;
2745 #endif /* DEBUG_FIFO */
2746 return 0;
2747 }
2748
2749 static int
2750 DumpTraceBuffer ( char __user *pData, int count )
2751 {
2752 #ifdef IP2DEBUG_TRACE
2753 int rc;
2754 int dumpcount;
2755 int chunk;
2756 int *pIndex = (int __user *)pData;
2757
2758 if ( count < (sizeof(int) * 6) ) {
2759 return -EIO;
2760 }
2761 rc = put_user(tracewrap, pIndex );
2762 rc = put_user(TRACEMAX, ++pIndex );
2763 rc = put_user(tracestrip, ++pIndex );
2764 rc = put_user(tracestuff, ++pIndex );
2765 pData += sizeof(int) * 6;
2766 count -= sizeof(int) * 6;
2767
2768 dumpcount = tracestuff - tracestrip;
2769 if ( dumpcount < 0 ) {
2770 dumpcount += TRACEMAX;
2771 }
2772 if ( dumpcount > count ) {
2773 dumpcount = count;
2774 }
2775 chunk = TRACEMAX - tracestrip;
2776 if ( dumpcount > chunk ) {
2777 rc = copy_to_user(pData, &tracebuf[tracestrip],
2778 chunk * sizeof(tracebuf[0]) );
2779 pData += chunk * sizeof(tracebuf[0]);
2780 tracestrip = 0;
2781 chunk = dumpcount - chunk;
2782 } else {
2783 chunk = dumpcount;
2784 }
2785 rc = copy_to_user(pData, &tracebuf[tracestrip],
2786 chunk * sizeof(tracebuf[0]) );
2787 tracestrip += chunk;
2788 tracewrap = 0;
2789
2790 rc = put_user(tracestrip, ++pIndex );
2791 rc = put_user(tracestuff, ++pIndex );
2792
2793 return dumpcount;
2794 #else
2795 return 0;
2796 #endif
2797 }
2798
2799 /******************************************************************************/
2800 /* Function: ip2_ipl_write() */
2801 /* Parameters: */
2802 /* Pointer to file structure */
2803 /* Pointer to data */
2804 /* Number of bytes to write */
2805 /* Returns: Success or failure */
2806 /* */
2807 /* Description: */
2808 /* */
2809 /* */
2810 /******************************************************************************/
2811 static ssize_t
2812 ip2_ipl_write(struct file *pFile, const char __user *pData, size_t count, loff_t *off)
2813 {
2814 #ifdef IP2DEBUG_IPL
2815 printk (KERN_DEBUG "IP2IPL: write %p, %d bytes\n", pData, count );
2816 #endif
2817 return 0;
2818 }
2819
2820 /******************************************************************************/
2821 /* Function: ip2_ipl_ioctl() */
2822 /* Parameters: Pointer to device inode */
2823 /* Pointer to file structure */
2824 /* Command */
2825 /* Argument */
2826 /* Returns: Success or failure */
2827 /* */
2828 /* Description: */
2829 /* */
2830 /* */
2831 /******************************************************************************/
2832 static int
2833 ip2_ipl_ioctl ( struct inode *pInode, struct file *pFile, UINT cmd, ULONG arg )
2834 {
2835 unsigned int iplminor = iminor(pInode);
2836 int rc = 0;
2837 void __user *argp = (void __user *)arg;
2838 ULONG __user *pIndex = argp;
2839 i2eBordStrPtr pB = i2BoardPtrTable[iplminor / 4];
2840 i2ChanStrPtr pCh;
2841
2842 #ifdef IP2DEBUG_IPL
2843 printk (KERN_DEBUG "IP2IPL: ioctl cmd %d, arg %ld\n", cmd, arg );
2844 #endif
2845
2846 switch ( iplminor ) {
2847 case 0: // IPL device
2848 rc = -EINVAL;
2849 break;
2850 case 1: // Status dump
2851 case 5:
2852 case 9:
2853 case 13:
2854 switch ( cmd ) {
2855 case 64: /* Driver - ip2stat */
2856 rc = put_user(ip2_tty_driver->refcount, pIndex++ );
2857 rc = put_user(irq_counter, pIndex++ );
2858 rc = put_user(bh_counter, pIndex++ );
2859 break;
2860
2861 case 65: /* Board - ip2stat */
2862 if ( pB ) {
2863 rc = copy_to_user(argp, pB, sizeof(i2eBordStr));
2864 rc = put_user(INB(pB->i2eStatus),
2865 (ULONG __user *)(arg + (ULONG)(&pB->i2eStatus) - (ULONG)pB ) );
2866 } else {
2867 rc = -ENODEV;
2868 }
2869 break;
2870
2871 default:
2872 if (cmd < IP2_MAX_PORTS) {
2873 pCh = DevTable[cmd];
2874 if ( pCh )
2875 {
2876 rc = copy_to_user(argp, pCh, sizeof(i2ChanStr));
2877 } else {
2878 rc = -ENODEV;
2879 }
2880 } else {
2881 rc = -EINVAL;
2882 }
2883 }
2884 break;
2885
2886 case 2: // Ping device
2887 rc = -EINVAL;
2888 break;
2889 case 3: // Trace device
2890 /*
2891 * akpm: This used to write a whole bunch of function addresses
2892 * to userspace, which generated lots of put_user() warnings.
2893 * I killed it all. Just return "success" and don't do
2894 * anything.
2895 */
2896 if (cmd == 1)
2897 rc = 0;
2898 else
2899 rc = -EINVAL;
2900 break;
2901
2902 default:
2903 rc = -ENODEV;
2904 break;
2905 }
2906 return rc;
2907 }
2908
2909 /******************************************************************************/
2910 /* Function: ip2_ipl_open() */
2911 /* Parameters: Pointer to device inode */
2912 /* Pointer to file structure */
2913 /* Returns: Success or failure */
2914 /* */
2915 /* Description: */
2916 /* */
2917 /* */
2918 /******************************************************************************/
2919 static int
2920 ip2_ipl_open( struct inode *pInode, struct file *pFile )
2921 {
2922 unsigned int iplminor = iminor(pInode);
2923 i2eBordStrPtr pB;
2924 i2ChanStrPtr pCh;
2925
2926 #ifdef IP2DEBUG_IPL
2927 printk (KERN_DEBUG "IP2IPL: open\n" );
2928 #endif
2929
2930 switch(iplminor) {
2931 // These are the IPL devices
2932 case 0:
2933 case 4:
2934 case 8:
2935 case 12:
2936 break;
2937
2938 // These are the status devices
2939 case 1:
2940 case 5:
2941 case 9:
2942 case 13:
2943 break;
2944
2945 // These are the debug devices
2946 case 2:
2947 case 6:
2948 case 10:
2949 case 14:
2950 pB = i2BoardPtrTable[iplminor / 4];
2951 pCh = (i2ChanStrPtr) pB->i2eChannelPtr;
2952 break;
2953
2954 // This is the trace device
2955 case 3:
2956 break;
2957 }
2958 return 0;
2959 }
2960 /******************************************************************************/
2961 /* Function: ip2_read_procmem */
2962 /* Parameters: */
2963 /* */
2964 /* Returns: Length of output */
2965 /* */
2966 /* Description: */
2967 /* Supplies some driver operating parameters */
2968 /* Not real useful unless your debugging the fifo */
2969 /* */
2970 /******************************************************************************/
2971
2972 #define LIMIT (PAGE_SIZE - 120)
2973
2974 static int
2975 ip2_read_procmem(char *buf, char **start, off_t offset, int len)
2976 {
2977 i2eBordStrPtr pB;
2978 i2ChanStrPtr pCh;
2979 PTTY tty;
2980 int i;
2981
2982 len = 0;
2983
2984 #define FMTLINE "%3d: 0x%08x 0x%08x 0%011o 0%011o\n"
2985 #define FMTLIN2 " 0x%04x 0x%04x tx flow 0x%x\n"
2986 #define FMTLIN3 " 0x%04x 0x%04x rc flow\n"
2987
2988 len += sprintf(buf+len,"\n");
2989
2990 for( i = 0; i < IP2_MAX_BOARDS; ++i ) {
2991 pB = i2BoardPtrTable[i];
2992 if ( pB ) {
2993 len += sprintf(buf+len,"board %d:\n",i);
2994 len += sprintf(buf+len,"\tFifo rem: %d mty: %x outM %x\n",
2995 pB->i2eFifoRemains,pB->i2eWaitingForEmptyFifo,pB->i2eOutMailWaiting);
2996 }
2997 }
2998
2999 len += sprintf(buf+len,"#: tty flags, port flags, cflags, iflags\n");
3000 for (i=0; i < IP2_MAX_PORTS; i++) {
3001 if (len > LIMIT)
3002 break;
3003 pCh = DevTable[i];
3004 if (pCh) {
3005 tty = pCh->pTTY;
3006 if (tty && tty->count) {
3007 len += sprintf(buf+len,FMTLINE,i,(int)tty->flags,pCh->flags,
3008 tty->termios->c_cflag,tty->termios->c_iflag);
3009
3010 len += sprintf(buf+len,FMTLIN2,
3011 pCh->outfl.asof,pCh->outfl.room,pCh->channelNeeds);
3012 len += sprintf(buf+len,FMTLIN3,pCh->infl.asof,pCh->infl.room);
3013 }
3014 }
3015 }
3016 return len;
3017 }
3018
3019 /*
3020 * This is the handler for /proc/tty/driver/ip2
3021 *
3022 * This stretch of code has been largely plagerized from at least three
3023 * different sources including ip2mkdev.c and a couple of other drivers.
3024 * The bugs are all mine. :-) =mhw=
3025 */
3026 static int ip2_read_proc(char *page, char **start, off_t off,
3027 int count, int *eof, void *data)
3028 {
3029 int i, j, box;
3030 int len = 0;
3031 int boxes = 0;
3032 int ports = 0;
3033 int tports = 0;
3034 off_t begin = 0;
3035 i2eBordStrPtr pB;
3036
3037 len += sprintf(page, "ip2info: 1.0 driver: %s\n", pcVersion );
3038 len += sprintf(page+len, "Driver: SMajor=%d CMajor=%d IMajor=%d MaxBoards=%d MaxBoxes=%d MaxPorts=%d\n",
3039 IP2_TTY_MAJOR, IP2_CALLOUT_MAJOR, IP2_IPL_MAJOR,
3040 IP2_MAX_BOARDS, ABS_MAX_BOXES, ABS_BIGGEST_BOX);
3041
3042 for( i = 0; i < IP2_MAX_BOARDS; ++i ) {
3043 /* This need to be reset for a board by board count... */
3044 boxes = 0;
3045 pB = i2BoardPtrTable[i];
3046 if( pB ) {
3047 switch( pB->i2ePom.e.porID & ~POR_ID_RESERVED )
3048 {
3049 case POR_ID_FIIEX:
3050 len += sprintf( page+len, "Board %d: EX ports=", i );
3051 for( box = 0; box < ABS_MAX_BOXES; ++box )
3052 {
3053 ports = 0;
3054
3055 if( pB->i2eChannelMap[box] != 0 ) ++boxes;
3056 for( j = 0; j < ABS_BIGGEST_BOX; ++j )
3057 {
3058 if( pB->i2eChannelMap[box] & 1<< j ) {
3059 ++ports;
3060 }
3061 }
3062 len += sprintf( page+len, "%d,", ports );
3063 tports += ports;
3064 }
3065
3066 --len; /* Backup over that last comma */
3067
3068 len += sprintf( page+len, " boxes=%d width=%d", boxes, pB->i2eDataWidth16 ? 16 : 8 );
3069 break;
3070
3071 case POR_ID_II_4:
3072 len += sprintf(page+len, "Board %d: ISA-4 ports=4 boxes=1", i );
3073 tports = ports = 4;
3074 break;
3075
3076 case POR_ID_II_8:
3077 len += sprintf(page+len, "Board %d: ISA-8-std ports=8 boxes=1", i );
3078 tports = ports = 8;
3079 break;
3080
3081 case POR_ID_II_8R:
3082 len += sprintf(page+len, "Board %d: ISA-8-RJ11 ports=8 boxes=1", i );
3083 tports = ports = 8;
3084 break;
3085
3086 default:
3087 len += sprintf(page+len, "Board %d: unknown", i );
3088 /* Don't try and probe for minor numbers */
3089 tports = ports = 0;
3090 }
3091
3092 } else {
3093 /* Don't try and probe for minor numbers */
3094 len += sprintf(page+len, "Board %d: vacant", i );
3095 tports = ports = 0;
3096 }
3097
3098 if( tports ) {
3099 len += sprintf(page+len, " minors=" );
3100
3101 for ( box = 0; box < ABS_MAX_BOXES; ++box )
3102 {
3103 for ( j = 0; j < ABS_BIGGEST_BOX; ++j )
3104 {
3105 if ( pB->i2eChannelMap[box] & (1 << j) )
3106 {
3107 len += sprintf (page+len,"%d,",
3108 j + ABS_BIGGEST_BOX *
3109 (box+i*ABS_MAX_BOXES));
3110 }
3111 }
3112 }
3113
3114 page[ len - 1 ] = '\n'; /* Overwrite that last comma */
3115 } else {
3116 len += sprintf (page+len,"\n" );
3117 }
3118
3119 if (len+begin > off+count)
3120 break;
3121 if (len+begin < off) {
3122 begin += len;
3123 len = 0;
3124 }
3125 }
3126
3127 if (i >= IP2_MAX_BOARDS)
3128 *eof = 1;
3129 if (off >= len+begin)
3130 return 0;
3131
3132 *start = page + (off-begin);
3133 return ((count < begin+len-off) ? count : begin+len-off);
3134 }
3135
3136 /******************************************************************************/
3137 /* Function: ip2trace() */
3138 /* Parameters: Value to add to trace buffer */
3139 /* Returns: Nothing */
3140 /* */
3141 /* Description: */
3142 /* */
3143 /* */
3144 /******************************************************************************/
3145 #ifdef IP2DEBUG_TRACE
3146 void
3147 ip2trace (unsigned short pn, unsigned char cat, unsigned char label, unsigned long codes, ...)
3148 {
3149 long flags;
3150 unsigned long *pCode = &codes;
3151 union ip2breadcrumb bc;
3152 i2ChanStrPtr pCh;
3153
3154
3155 tracebuf[tracestuff++] = jiffies;
3156 if ( tracestuff == TRACEMAX ) {
3157 tracestuff = 0;
3158 }
3159 if ( tracestuff == tracestrip ) {
3160 if ( ++tracestrip == TRACEMAX ) {
3161 tracestrip = 0;
3162 }
3163 ++tracewrap;
3164 }
3165
3166 bc.hdr.port = 0xff & pn;
3167 bc.hdr.cat = cat;
3168 bc.hdr.codes = (unsigned char)( codes & 0xff );
3169 bc.hdr.label = label;
3170 tracebuf[tracestuff++] = bc.value;
3171
3172 for (;;) {
3173 if ( tracestuff == TRACEMAX ) {
3174 tracestuff = 0;
3175 }
3176 if ( tracestuff == tracestrip ) {
3177 if ( ++tracestrip == TRACEMAX ) {
3178 tracestrip = 0;
3179 }
3180 ++tracewrap;
3181 }
3182
3183 if ( !codes-- )
3184 break;
3185
3186 tracebuf[tracestuff++] = *++pCode;
3187 }
3188 }
3189 #endif
3190
3191
3192 MODULE_LICENSE("GPL");
3193
3194 static struct pci_device_id ip2main_pci_tbl[] __devinitdata = {
3195 { PCI_DEVICE(PCI_VENDOR_ID_COMPUTONE, PCI_DEVICE_ID_COMPUTONE_IP2EX) },
3196 { }
3197 };
3198
3199 MODULE_DEVICE_TABLE(pci, ip2main_pci_tbl);
Linux kernel - Deliverables
This page took 0.10351 seconds and 6 git commands to generate.