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