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