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