1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29#include <linux/module.h>
30#include <linux/sched.h>
31#include <linux/slab.h>
32#include <linux/interrupt.h>
33#include <linux/tty.h>
34#include <linux/tty_flip.h>
35#include <linux/serial.h>
36#include <linux/seq_file.h>
37#include <linux/cd1400.h>
38#include <linux/sc26198.h>
39#include <linux/comstats.h>
40#include <linux/stallion.h>
41#include <linux/ioport.h>
42#include <linux/init.h>
43#include <linux/device.h>
44#include <linux/delay.h>
45#include <linux/ctype.h>
46
47#include <asm/io.h>
48#include <asm/uaccess.h>
49
50#include <linux/pci.h>
51
52
53
54
55
56
57
58
59#define BRD_EASYIO 20
60#define BRD_ECH 21
61#define BRD_ECHMC 22
62#define BRD_ECHPCI 26
63#define BRD_ECH64PCI 27
64#define BRD_EASYIOPCI 28
65
66struct stlconf {
67 unsigned int brdtype;
68 int ioaddr1;
69 int ioaddr2;
70 unsigned long memaddr;
71 int irq;
72 int irqtype;
73};
74
75static unsigned int stl_nrbrds;
76
77
78
79
80
81
82
83#ifndef STL_SIOMEMMAJOR
84#define STL_SIOMEMMAJOR 28
85#endif
86#ifndef STL_SERIALMAJOR
87#define STL_SERIALMAJOR 24
88#endif
89#ifndef STL_CALLOUTMAJOR
90#define STL_CALLOUTMAJOR 25
91#endif
92
93
94
95
96
97#define STL_TXBUFLOW 512
98#define STL_TXBUFSIZE 4096
99
100
101
102
103
104
105
106static char *stl_drvtitle = "Stallion Multiport Serial Driver";
107static char *stl_drvname = "stallion";
108static char *stl_drvversion = "5.6.0";
109
110static struct tty_driver *stl_serial;
111
112
113
114
115
116
117static struct ktermios stl_deftermios = {
118 .c_cflag = (B9600 | CS8 | CREAD | HUPCL | CLOCAL),
119 .c_cc = INIT_C_CC,
120 .c_ispeed = 9600,
121 .c_ospeed = 9600,
122};
123
124
125
126
127static char stl_unwanted[SC26198_RXFIFOSIZE];
128
129
130
131static DEFINE_MUTEX(stl_brdslock);
132static struct stlbrd *stl_brds[STL_MAXBRDS];
133
134static const struct tty_port_operations stl_port_ops;
135
136
137
138
139
140#define BRD_FOUND 0x1
141#define STL_PROBED 0x2
142
143
144
145
146
147
148
149#define ASYI_TXBUSY 1
150#define ASYI_TXLOW 2
151#define ASYI_TXFLOWED 3
152
153
154
155
156
157static char *stl_brdnames[] = {
158 NULL,
159 NULL,
160 NULL,
161 NULL,
162 NULL,
163 NULL,
164 NULL,
165 NULL,
166 NULL,
167 NULL,
168 NULL,
169 NULL,
170 NULL,
171 NULL,
172 NULL,
173 NULL,
174 NULL,
175 NULL,
176 NULL,
177 NULL,
178 "EasyIO",
179 "EC8/32-AT",
180 "EC8/32-MC",
181 NULL,
182 NULL,
183 NULL,
184 "EC8/32-PCI",
185 "EC8/64-PCI",
186 "EasyIO-PCI",
187};
188
189
190
191
192
193
194
195
196static unsigned int stl_nargs;
197static char *board0[4];
198static char *board1[4];
199static char *board2[4];
200static char *board3[4];
201
202static char **stl_brdsp[] = {
203 (char **) &board0,
204 (char **) &board1,
205 (char **) &board2,
206 (char **) &board3
207};
208
209
210
211
212
213
214static struct {
215 char *name;
216 int type;
217} stl_brdstr[] = {
218 { "easyio", BRD_EASYIO },
219 { "eio", BRD_EASYIO },
220 { "20", BRD_EASYIO },
221 { "ec8/32", BRD_ECH },
222 { "ec8/32-at", BRD_ECH },
223 { "ec8/32-isa", BRD_ECH },
224 { "ech", BRD_ECH },
225 { "echat", BRD_ECH },
226 { "21", BRD_ECH },
227 { "ec8/32-mc", BRD_ECHMC },
228 { "ec8/32-mca", BRD_ECHMC },
229 { "echmc", BRD_ECHMC },
230 { "echmca", BRD_ECHMC },
231 { "22", BRD_ECHMC },
232 { "ec8/32-pc", BRD_ECHPCI },
233 { "ec8/32-pci", BRD_ECHPCI },
234 { "26", BRD_ECHPCI },
235 { "ec8/64-pc", BRD_ECH64PCI },
236 { "ec8/64-pci", BRD_ECH64PCI },
237 { "ech-pci", BRD_ECH64PCI },
238 { "echpci", BRD_ECH64PCI },
239 { "echpc", BRD_ECH64PCI },
240 { "27", BRD_ECH64PCI },
241 { "easyio-pc", BRD_EASYIOPCI },
242 { "easyio-pci", BRD_EASYIOPCI },
243 { "eio-pci", BRD_EASYIOPCI },
244 { "eiopci", BRD_EASYIOPCI },
245 { "28", BRD_EASYIOPCI },
246};
247
248
249
250
251
252module_param_array(board0, charp, &stl_nargs, 0);
253MODULE_PARM_DESC(board0, "Board 0 config -> name[,ioaddr[,ioaddr2][,irq]]");
254module_param_array(board1, charp, &stl_nargs, 0);
255MODULE_PARM_DESC(board1, "Board 1 config -> name[,ioaddr[,ioaddr2][,irq]]");
256module_param_array(board2, charp, &stl_nargs, 0);
257MODULE_PARM_DESC(board2, "Board 2 config -> name[,ioaddr[,ioaddr2][,irq]]");
258module_param_array(board3, charp, &stl_nargs, 0);
259MODULE_PARM_DESC(board3, "Board 3 config -> name[,ioaddr[,ioaddr2][,irq]]");
260
261
262
263
264
265
266
267
268#define EIO_8PORTRS 0x04
269#define EIO_4PORTRS 0x05
270#define EIO_8PORTDI 0x00
271#define EIO_8PORTM 0x06
272#define EIO_MK3 0x03
273#define EIO_IDBITMASK 0x07
274
275#define EIO_BRDMASK 0xf0
276#define ID_BRD4 0x10
277#define ID_BRD8 0x20
278#define ID_BRD16 0x30
279
280#define EIO_INTRPEND 0x08
281#define EIO_INTEDGE 0x00
282#define EIO_INTLEVEL 0x08
283#define EIO_0WS 0x10
284
285#define ECH_ID 0xa0
286#define ECH_IDBITMASK 0xe0
287#define ECH_BRDENABLE 0x08
288#define ECH_BRDDISABLE 0x00
289#define ECH_INTENABLE 0x01
290#define ECH_INTDISABLE 0x00
291#define ECH_INTLEVEL 0x02
292#define ECH_INTEDGE 0x00
293#define ECH_INTRPEND 0x01
294#define ECH_BRDRESET 0x01
295
296#define ECHMC_INTENABLE 0x01
297#define ECHMC_BRDRESET 0x02
298
299#define ECH_PNLSTATUS 2
300#define ECH_PNL16PORT 0x20
301#define ECH_PNLIDMASK 0x07
302#define ECH_PNLXPID 0x40
303#define ECH_PNLINTRPEND 0x80
304
305#define ECH_ADDR2MASK 0x1e0
306
307
308
309
310
311
312static unsigned char stl_vecmap[] = {
313 0xff, 0xff, 0xff, 0x04, 0x06, 0x05, 0xff, 0x07,
314 0xff, 0xff, 0x00, 0x02, 0x01, 0xff, 0xff, 0x03
315};
316
317
318
319
320
321
322static spinlock_t brd_lock;
323static spinlock_t stallion_lock;
324
325
326
327
328
329
330
331
332#define BRDENABLE(brdnr,pagenr) \
333 if (stl_brds[(brdnr)]->brdtype == BRD_ECH) \
334 outb((stl_brds[(brdnr)]->ioctrlval | ECH_BRDENABLE), \
335 stl_brds[(brdnr)]->ioctrl); \
336 else if (stl_brds[(brdnr)]->brdtype == BRD_ECHPCI) \
337 outb((pagenr), stl_brds[(brdnr)]->ioctrl);
338
339#define BRDDISABLE(brdnr) \
340 if (stl_brds[(brdnr)]->brdtype == BRD_ECH) \
341 outb((stl_brds[(brdnr)]->ioctrlval | ECH_BRDDISABLE), \
342 stl_brds[(brdnr)]->ioctrl);
343
344#define STL_CD1400MAXBAUD 230400
345#define STL_SC26198MAXBAUD 460800
346
347#define STL_BAUDBASE 115200
348#define STL_CLOSEDELAY (5 * HZ / 10)
349
350
351
352
353
354
355#ifndef PCI_VENDOR_ID_STALLION
356#define PCI_VENDOR_ID_STALLION 0x124d
357#endif
358#ifndef PCI_DEVICE_ID_ECHPCI832
359#define PCI_DEVICE_ID_ECHPCI832 0x0000
360#endif
361#ifndef PCI_DEVICE_ID_ECHPCI864
362#define PCI_DEVICE_ID_ECHPCI864 0x0002
363#endif
364#ifndef PCI_DEVICE_ID_EIOPCI
365#define PCI_DEVICE_ID_EIOPCI 0x0003
366#endif
367
368
369
370
371
372static struct pci_device_id stl_pcibrds[] = {
373 { PCI_DEVICE(PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_ECHPCI864),
374 .driver_data = BRD_ECH64PCI },
375 { PCI_DEVICE(PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_EIOPCI),
376 .driver_data = BRD_EASYIOPCI },
377 { PCI_DEVICE(PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_ECHPCI832),
378 .driver_data = BRD_ECHPCI },
379 { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_87410),
380 .driver_data = BRD_ECHPCI },
381 { }
382};
383MODULE_DEVICE_TABLE(pci, stl_pcibrds);
384
385
386
387
388
389
390#define MINOR2BRD(min) (((min) & 0xc0) >> 6)
391#define MINOR2PORT(min) ((min) & 0x3f)
392
393
394
395
396
397
398static unsigned int stl_baudrates[] = {
399 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
400 9600, 19200, 38400, 57600, 115200, 230400, 460800, 921600
401};
402
403
404
405
406
407
408
409static long stl_memioctl(struct file *fp, unsigned int cmd, unsigned long arg);
410static int stl_brdinit(struct stlbrd *brdp);
411static int stl_getportstats(struct tty_struct *tty, struct stlport *portp, comstats_t __user *cp);
412static int stl_clrportstats(struct stlport *portp, comstats_t __user *cp);
413
414
415
416
417static void stl_cd1400setreg(struct stlport *portp, int regnr, int value);
418static int stl_cd1400getreg(struct stlport *portp, int regnr);
419static int stl_cd1400updatereg(struct stlport *portp, int regnr, int value);
420static int stl_cd1400panelinit(struct stlbrd *brdp, struct stlpanel *panelp);
421static void stl_cd1400portinit(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp);
422static void stl_cd1400setport(struct stlport *portp, struct ktermios *tiosp);
423static int stl_cd1400getsignals(struct stlport *portp);
424static void stl_cd1400setsignals(struct stlport *portp, int dtr, int rts);
425static void stl_cd1400ccrwait(struct stlport *portp);
426static void stl_cd1400enablerxtx(struct stlport *portp, int rx, int tx);
427static void stl_cd1400startrxtx(struct stlport *portp, int rx, int tx);
428static void stl_cd1400disableintrs(struct stlport *portp);
429static void stl_cd1400sendbreak(struct stlport *portp, int len);
430static void stl_cd1400flowctrl(struct stlport *portp, int state);
431static void stl_cd1400sendflow(struct stlport *portp, int state);
432static void stl_cd1400flush(struct stlport *portp);
433static int stl_cd1400datastate(struct stlport *portp);
434static void stl_cd1400eiointr(struct stlpanel *panelp, unsigned int iobase);
435static void stl_cd1400echintr(struct stlpanel *panelp, unsigned int iobase);
436static void stl_cd1400txisr(struct stlpanel *panelp, int ioaddr);
437static void stl_cd1400rxisr(struct stlpanel *panelp, int ioaddr);
438static void stl_cd1400mdmisr(struct stlpanel *panelp, int ioaddr);
439
440static inline int stl_cd1400breakisr(struct stlport *portp, int ioaddr);
441
442
443
444
445static void stl_sc26198setreg(struct stlport *portp, int regnr, int value);
446static int stl_sc26198getreg(struct stlport *portp, int regnr);
447static int stl_sc26198updatereg(struct stlport *portp, int regnr, int value);
448static int stl_sc26198getglobreg(struct stlport *portp, int regnr);
449static int stl_sc26198panelinit(struct stlbrd *brdp, struct stlpanel *panelp);
450static void stl_sc26198portinit(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp);
451static void stl_sc26198setport(struct stlport *portp, struct ktermios *tiosp);
452static int stl_sc26198getsignals(struct stlport *portp);
453static void stl_sc26198setsignals(struct stlport *portp, int dtr, int rts);
454static void stl_sc26198enablerxtx(struct stlport *portp, int rx, int tx);
455static void stl_sc26198startrxtx(struct stlport *portp, int rx, int tx);
456static void stl_sc26198disableintrs(struct stlport *portp);
457static void stl_sc26198sendbreak(struct stlport *portp, int len);
458static void stl_sc26198flowctrl(struct stlport *portp, int state);
459static void stl_sc26198sendflow(struct stlport *portp, int state);
460static void stl_sc26198flush(struct stlport *portp);
461static int stl_sc26198datastate(struct stlport *portp);
462static void stl_sc26198wait(struct stlport *portp);
463static void stl_sc26198txunflow(struct stlport *portp, struct tty_struct *tty);
464static void stl_sc26198intr(struct stlpanel *panelp, unsigned int iobase);
465static void stl_sc26198txisr(struct stlport *port);
466static void stl_sc26198rxisr(struct stlport *port, unsigned int iack);
467static void stl_sc26198rxbadch(struct stlport *portp, unsigned char status, char ch);
468static void stl_sc26198rxbadchars(struct stlport *portp);
469static void stl_sc26198otherisr(struct stlport *port, unsigned int iack);
470
471
472
473
474
475
476typedef struct uart {
477 int (*panelinit)(struct stlbrd *brdp, struct stlpanel *panelp);
478 void (*portinit)(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp);
479 void (*setport)(struct stlport *portp, struct ktermios *tiosp);
480 int (*getsignals)(struct stlport *portp);
481 void (*setsignals)(struct stlport *portp, int dtr, int rts);
482 void (*enablerxtx)(struct stlport *portp, int rx, int tx);
483 void (*startrxtx)(struct stlport *portp, int rx, int tx);
484 void (*disableintrs)(struct stlport *portp);
485 void (*sendbreak)(struct stlport *portp, int len);
486 void (*flowctrl)(struct stlport *portp, int state);
487 void (*sendflow)(struct stlport *portp, int state);
488 void (*flush)(struct stlport *portp);
489 int (*datastate)(struct stlport *portp);
490 void (*intr)(struct stlpanel *panelp, unsigned int iobase);
491} uart_t;
492
493
494
495
496#define stl_panelinit (* ((uart_t *) panelp->uartp)->panelinit)
497#define stl_portinit (* ((uart_t *) portp->uartp)->portinit)
498#define stl_setport (* ((uart_t *) portp->uartp)->setport)
499#define stl_getsignals (* ((uart_t *) portp->uartp)->getsignals)
500#define stl_setsignals (* ((uart_t *) portp->uartp)->setsignals)
501#define stl_enablerxtx (* ((uart_t *) portp->uartp)->enablerxtx)
502#define stl_startrxtx (* ((uart_t *) portp->uartp)->startrxtx)
503#define stl_disableintrs (* ((uart_t *) portp->uartp)->disableintrs)
504#define stl_sendbreak (* ((uart_t *) portp->uartp)->sendbreak)
505#define stl_flowctrl (* ((uart_t *) portp->uartp)->flowctrl)
506#define stl_sendflow (* ((uart_t *) portp->uartp)->sendflow)
507#define stl_flush (* ((uart_t *) portp->uartp)->flush)
508#define stl_datastate (* ((uart_t *) portp->uartp)->datastate)
509
510
511
512
513
514
515static uart_t stl_cd1400uart = {
516 stl_cd1400panelinit,
517 stl_cd1400portinit,
518 stl_cd1400setport,
519 stl_cd1400getsignals,
520 stl_cd1400setsignals,
521 stl_cd1400enablerxtx,
522 stl_cd1400startrxtx,
523 stl_cd1400disableintrs,
524 stl_cd1400sendbreak,
525 stl_cd1400flowctrl,
526 stl_cd1400sendflow,
527 stl_cd1400flush,
528 stl_cd1400datastate,
529 stl_cd1400eiointr
530};
531
532
533
534
535
536#define EREG_ADDR 0
537#define EREG_DATA 4
538#define EREG_RXACK 5
539#define EREG_TXACK 6
540#define EREG_MDACK 7
541
542#define EREG_BANKSIZE 8
543
544#define CD1400_CLK 25000000
545#define CD1400_CLK8M 20000000
546
547
548
549
550
551
552static int stl_cd1400clkdivs[] = {
553 CD1400_CLK0, CD1400_CLK1, CD1400_CLK2, CD1400_CLK3, CD1400_CLK4
554};
555
556
557
558
559
560
561static uart_t stl_sc26198uart = {
562 stl_sc26198panelinit,
563 stl_sc26198portinit,
564 stl_sc26198setport,
565 stl_sc26198getsignals,
566 stl_sc26198setsignals,
567 stl_sc26198enablerxtx,
568 stl_sc26198startrxtx,
569 stl_sc26198disableintrs,
570 stl_sc26198sendbreak,
571 stl_sc26198flowctrl,
572 stl_sc26198sendflow,
573 stl_sc26198flush,
574 stl_sc26198datastate,
575 stl_sc26198intr
576};
577
578
579
580
581#define XP_DATA 0
582#define XP_ADDR 1
583#define XP_MODID 2
584#define XP_STATUS 2
585#define XP_IACK 3
586
587#define XP_BANKSIZE 4
588
589
590
591
592
593static unsigned int sc26198_baudtable[] = {
594 50, 75, 150, 200, 300, 450, 600, 900, 1200, 1800, 2400, 3600,
595 4800, 7200, 9600, 14400, 19200, 28800, 38400, 57600, 115200,
596 230400, 460800, 921600
597};
598
599#define SC26198_NRBAUDS ARRAY_SIZE(sc26198_baudtable)
600
601
602
603
604
605
606
607static const struct file_operations stl_fsiomem = {
608 .owner = THIS_MODULE,
609 .unlocked_ioctl = stl_memioctl,
610 .llseek = noop_llseek,
611};
612
613static struct class *stallion_class;
614
615static void stl_cd_change(struct stlport *portp)
616{
617 unsigned int oldsigs = portp->sigs;
618 struct tty_struct *tty = tty_port_tty_get(&portp->port);
619
620 if (!tty)
621 return;
622
623 portp->sigs = stl_getsignals(portp);
624
625 if ((portp->sigs & TIOCM_CD) && ((oldsigs & TIOCM_CD) == 0))
626 wake_up_interruptible(&portp->port.open_wait);
627
628 if ((oldsigs & TIOCM_CD) && ((portp->sigs & TIOCM_CD) == 0))
629 if (portp->port.flags & ASYNC_CHECK_CD)
630 tty_hangup(tty);
631 tty_kref_put(tty);
632}
633
634
635
636
637
638
639
640
641
642
643
644static int __init stl_parsebrd(struct stlconf *confp, char **argp)
645{
646 char *sp;
647 unsigned int i;
648
649 pr_debug("stl_parsebrd(confp=%p,argp=%p)\n", confp, argp);
650
651 if ((argp[0] == NULL) || (*argp[0] == 0))
652 return 0;
653
654 for (sp = argp[0], i = 0; (*sp != 0) && (i < 25); sp++, i++)
655 *sp = tolower(*sp);
656
657 for (i = 0; i < ARRAY_SIZE(stl_brdstr); i++)
658 if (strcmp(stl_brdstr[i].name, argp[0]) == 0)
659 break;
660
661 if (i == ARRAY_SIZE(stl_brdstr)) {
662 printk("STALLION: unknown board name, %s?\n", argp[0]);
663 return 0;
664 }
665
666 confp->brdtype = stl_brdstr[i].type;
667
668 i = 1;
669 if ((argp[i] != NULL) && (*argp[i] != 0))
670 confp->ioaddr1 = simple_strtoul(argp[i], NULL, 0);
671 i++;
672 if (confp->brdtype == BRD_ECH) {
673 if ((argp[i] != NULL) && (*argp[i] != 0))
674 confp->ioaddr2 = simple_strtoul(argp[i], NULL, 0);
675 i++;
676 }
677 if ((argp[i] != NULL) && (*argp[i] != 0))
678 confp->irq = simple_strtoul(argp[i], NULL, 0);
679 return 1;
680}
681
682
683
684
685
686
687
688static struct stlbrd *stl_allocbrd(void)
689{
690 struct stlbrd *brdp;
691
692 brdp = kzalloc(sizeof(struct stlbrd), GFP_KERNEL);
693 if (!brdp) {
694 printk("STALLION: failed to allocate memory (size=%Zd)\n",
695 sizeof(struct stlbrd));
696 return NULL;
697 }
698
699 brdp->magic = STL_BOARDMAGIC;
700 return brdp;
701}
702
703
704
705static int stl_activate(struct tty_port *port, struct tty_struct *tty)
706{
707 struct stlport *portp = container_of(port, struct stlport, port);
708 if (!portp->tx.buf) {
709 portp->tx.buf = kmalloc(STL_TXBUFSIZE, GFP_KERNEL);
710 if (!portp->tx.buf)
711 return -ENOMEM;
712 portp->tx.head = portp->tx.buf;
713 portp->tx.tail = portp->tx.buf;
714 }
715 stl_setport(portp, tty->termios);
716 portp->sigs = stl_getsignals(portp);
717 stl_setsignals(portp, 1, 1);
718 stl_enablerxtx(portp, 1, 1);
719 stl_startrxtx(portp, 1, 0);
720 return 0;
721}
722
723static int stl_open(struct tty_struct *tty, struct file *filp)
724{
725 struct stlport *portp;
726 struct stlbrd *brdp;
727 unsigned int minordev, brdnr, panelnr;
728 int portnr;
729
730 pr_debug("stl_open(tty=%p,filp=%p): device=%s\n", tty, filp, tty->name);
731
732 minordev = tty->index;
733 brdnr = MINOR2BRD(minordev);
734 if (brdnr >= stl_nrbrds)
735 return -ENODEV;
736 brdp = stl_brds[brdnr];
737 if (brdp == NULL)
738 return -ENODEV;
739
740 minordev = MINOR2PORT(minordev);
741 for (portnr = -1, panelnr = 0; panelnr < STL_MAXPANELS; panelnr++) {
742 if (brdp->panels[panelnr] == NULL)
743 break;
744 if (minordev < brdp->panels[panelnr]->nrports) {
745 portnr = minordev;
746 break;
747 }
748 minordev -= brdp->panels[panelnr]->nrports;
749 }
750 if (portnr < 0)
751 return -ENODEV;
752
753 portp = brdp->panels[panelnr]->ports[portnr];
754 if (portp == NULL)
755 return -ENODEV;
756
757 tty->driver_data = portp;
758 return tty_port_open(&portp->port, tty, filp);
759
760}
761
762
763
764static int stl_carrier_raised(struct tty_port *port)
765{
766 struct stlport *portp = container_of(port, struct stlport, port);
767 return (portp->sigs & TIOCM_CD) ? 1 : 0;
768}
769
770static void stl_dtr_rts(struct tty_port *port, int on)
771{
772 struct stlport *portp = container_of(port, struct stlport, port);
773
774 stl_setsignals(portp, on, on);
775}
776
777
778
779static void stl_flushbuffer(struct tty_struct *tty)
780{
781 struct stlport *portp;
782
783 pr_debug("stl_flushbuffer(tty=%p)\n", tty);
784
785 portp = tty->driver_data;
786 if (portp == NULL)
787 return;
788
789 stl_flush(portp);
790 tty_wakeup(tty);
791}
792
793
794
795static void stl_waituntilsent(struct tty_struct *tty, int timeout)
796{
797 struct stlport *portp;
798 unsigned long tend;
799
800 pr_debug("stl_waituntilsent(tty=%p,timeout=%d)\n", tty, timeout);
801
802 portp = tty->driver_data;
803 if (portp == NULL)
804 return;
805
806 if (timeout == 0)
807 timeout = HZ;
808 tend = jiffies + timeout;
809
810 while (stl_datastate(portp)) {
811 if (signal_pending(current))
812 break;
813 msleep_interruptible(20);
814 if (time_after_eq(jiffies, tend))
815 break;
816 }
817}
818
819
820
821static void stl_shutdown(struct tty_port *port)
822{
823 struct stlport *portp = container_of(port, struct stlport, port);
824 stl_disableintrs(portp);
825 stl_enablerxtx(portp, 0, 0);
826 stl_flush(portp);
827 portp->istate = 0;
828 if (portp->tx.buf != NULL) {
829 kfree(portp->tx.buf);
830 portp->tx.buf = NULL;
831 portp->tx.head = NULL;
832 portp->tx.tail = NULL;
833 }
834}
835
836static void stl_close(struct tty_struct *tty, struct file *filp)
837{
838 struct stlport*portp;
839 pr_debug("stl_close(tty=%p,filp=%p)\n", tty, filp);
840
841 portp = tty->driver_data;
842 if(portp == NULL)
843 return;
844 tty_port_close(&portp->port, tty, filp);
845}
846
847
848
849
850
851
852
853
854static int stl_write(struct tty_struct *tty, const unsigned char *buf, int count)
855{
856 struct stlport *portp;
857 unsigned int len, stlen;
858 unsigned char *chbuf;
859 char *head, *tail;
860
861 pr_debug("stl_write(tty=%p,buf=%p,count=%d)\n", tty, buf, count);
862
863 portp = tty->driver_data;
864 if (portp == NULL)
865 return 0;
866 if (portp->tx.buf == NULL)
867 return 0;
868
869
870
871
872
873
874
875 chbuf = (unsigned char *) buf;
876
877 head = portp->tx.head;
878 tail = portp->tx.tail;
879 if (head >= tail) {
880 len = STL_TXBUFSIZE - (head - tail) - 1;
881 stlen = STL_TXBUFSIZE - (head - portp->tx.buf);
882 } else {
883 len = tail - head - 1;
884 stlen = len;
885 }
886
887 len = min(len, (unsigned int)count);
888 count = 0;
889 while (len > 0) {
890 stlen = min(len, stlen);
891 memcpy(head, chbuf, stlen);
892 len -= stlen;
893 chbuf += stlen;
894 count += stlen;
895 head += stlen;
896 if (head >= (portp->tx.buf + STL_TXBUFSIZE)) {
897 head = portp->tx.buf;
898 stlen = tail - head;
899 }
900 }
901 portp->tx.head = head;
902
903 clear_bit(ASYI_TXLOW, &portp->istate);
904 stl_startrxtx(portp, -1, 1);
905
906 return count;
907}
908
909
910
911static int stl_putchar(struct tty_struct *tty, unsigned char ch)
912{
913 struct stlport *portp;
914 unsigned int len;
915 char *head, *tail;
916
917 pr_debug("stl_putchar(tty=%p,ch=%x)\n", tty, ch);
918
919 portp = tty->driver_data;
920 if (portp == NULL)
921 return -EINVAL;
922 if (portp->tx.buf == NULL)
923 return -EINVAL;
924
925 head = portp->tx.head;
926 tail = portp->tx.tail;
927
928 len = (head >= tail) ? (STL_TXBUFSIZE - (head - tail)) : (tail - head);
929 len--;
930
931 if (len > 0) {
932 *head++ = ch;
933 if (head >= (portp->tx.buf + STL_TXBUFSIZE))
934 head = portp->tx.buf;
935 }
936 portp->tx.head = head;
937 return 0;
938}
939
940
941
942
943
944
945
946
947
948static void stl_flushchars(struct tty_struct *tty)
949{
950 struct stlport *portp;
951
952 pr_debug("stl_flushchars(tty=%p)\n", tty);
953
954 portp = tty->driver_data;
955 if (portp == NULL)
956 return;
957 if (portp->tx.buf == NULL)
958 return;
959
960 stl_startrxtx(portp, -1, 1);
961}
962
963
964
965static int stl_writeroom(struct tty_struct *tty)
966{
967 struct stlport *portp;
968 char *head, *tail;
969
970 pr_debug("stl_writeroom(tty=%p)\n", tty);
971
972 portp = tty->driver_data;
973 if (portp == NULL)
974 return 0;
975 if (portp->tx.buf == NULL)
976 return 0;
977
978 head = portp->tx.head;
979 tail = portp->tx.tail;
980 return (head >= tail) ? (STL_TXBUFSIZE - (head - tail) - 1) : (tail - head - 1);
981}
982
983
984
985
986
987
988
989
990
991
992
993
994static int stl_charsinbuffer(struct tty_struct *tty)
995{
996 struct stlport *portp;
997 unsigned int size;
998 char *head, *tail;
999
1000 pr_debug("stl_charsinbuffer(tty=%p)\n", tty);
1001
1002 portp = tty->driver_data;
1003 if (portp == NULL)
1004 return 0;
1005 if (portp->tx.buf == NULL)
1006 return 0;
1007
1008 head = portp->tx.head;
1009 tail = portp->tx.tail;
1010 size = (head >= tail) ? (head - tail) : (STL_TXBUFSIZE - (tail - head));
1011 if ((size == 0) && test_bit(ASYI_TXBUSY, &portp->istate))
1012 size = 1;
1013 return size;
1014}
1015
1016
1017
1018
1019
1020
1021
1022static int stl_getserial(struct stlport *portp, struct serial_struct __user *sp)
1023{
1024 struct serial_struct sio;
1025 struct stlbrd *brdp;
1026
1027 pr_debug("stl_getserial(portp=%p,sp=%p)\n", portp, sp);
1028
1029 memset(&sio, 0, sizeof(struct serial_struct));
1030
1031 mutex_lock(&portp->port.mutex);
1032 sio.line = portp->portnr;
1033 sio.port = portp->ioaddr;
1034 sio.flags = portp->port.flags;
1035 sio.baud_base = portp->baud_base;
1036 sio.close_delay = portp->close_delay;
1037 sio.closing_wait = portp->closing_wait;
1038 sio.custom_divisor = portp->custom_divisor;
1039 sio.hub6 = 0;
1040 if (portp->uartp == &stl_cd1400uart) {
1041 sio.type = PORT_CIRRUS;
1042 sio.xmit_fifo_size = CD1400_TXFIFOSIZE;
1043 } else {
1044 sio.type = PORT_UNKNOWN;
1045 sio.xmit_fifo_size = SC26198_TXFIFOSIZE;
1046 }
1047
1048 brdp = stl_brds[portp->brdnr];
1049 if (brdp != NULL)
1050 sio.irq = brdp->irq;
1051 mutex_unlock(&portp->port.mutex);
1052
1053 return copy_to_user(sp, &sio, sizeof(struct serial_struct)) ? -EFAULT : 0;
1054}
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064static int stl_setserial(struct tty_struct *tty, struct serial_struct __user *sp)
1065{
1066 struct stlport * portp = tty->driver_data;
1067 struct serial_struct sio;
1068
1069 pr_debug("stl_setserial(portp=%p,sp=%p)\n", portp, sp);
1070
1071 if (copy_from_user(&sio, sp, sizeof(struct serial_struct)))
1072 return -EFAULT;
1073 mutex_lock(&portp->port.mutex);
1074 if (!capable(CAP_SYS_ADMIN)) {
1075 if ((sio.baud_base != portp->baud_base) ||
1076 (sio.close_delay != portp->close_delay) ||
1077 ((sio.flags & ~ASYNC_USR_MASK) !=
1078 (portp->port.flags & ~ASYNC_USR_MASK))) {
1079 mutex_unlock(&portp->port.mutex);
1080 return -EPERM;
1081 }
1082 }
1083
1084 portp->port.flags = (portp->port.flags & ~ASYNC_USR_MASK) |
1085 (sio.flags & ASYNC_USR_MASK);
1086 portp->baud_base = sio.baud_base;
1087 portp->close_delay = sio.close_delay;
1088 portp->closing_wait = sio.closing_wait;
1089 portp->custom_divisor = sio.custom_divisor;
1090 mutex_unlock(&portp->port.mutex);
1091 stl_setport(portp, tty->termios);
1092 return 0;
1093}
1094
1095
1096
1097static int stl_tiocmget(struct tty_struct *tty, struct file *file)
1098{
1099 struct stlport *portp;
1100
1101 portp = tty->driver_data;
1102 if (portp == NULL)
1103 return -ENODEV;
1104 if (tty->flags & (1 << TTY_IO_ERROR))
1105 return -EIO;
1106
1107 return stl_getsignals(portp);
1108}
1109
1110static int stl_tiocmset(struct tty_struct *tty, struct file *file,
1111 unsigned int set, unsigned int clear)
1112{
1113 struct stlport *portp;
1114 int rts = -1, dtr = -1;
1115
1116 portp = tty->driver_data;
1117 if (portp == NULL)
1118 return -ENODEV;
1119 if (tty->flags & (1 << TTY_IO_ERROR))
1120 return -EIO;
1121
1122 if (set & TIOCM_RTS)
1123 rts = 1;
1124 if (set & TIOCM_DTR)
1125 dtr = 1;
1126 if (clear & TIOCM_RTS)
1127 rts = 0;
1128 if (clear & TIOCM_DTR)
1129 dtr = 0;
1130
1131 stl_setsignals(portp, dtr, rts);
1132 return 0;
1133}
1134
1135static int stl_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
1136{
1137 struct stlport *portp;
1138 int rc;
1139 void __user *argp = (void __user *)arg;
1140
1141 pr_debug("stl_ioctl(tty=%p,file=%p,cmd=%x,arg=%lx)\n", tty, file, cmd,
1142 arg);
1143
1144 portp = tty->driver_data;
1145 if (portp == NULL)
1146 return -ENODEV;
1147
1148 if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
1149 (cmd != COM_GETPORTSTATS) && (cmd != COM_CLRPORTSTATS))
1150 if (tty->flags & (1 << TTY_IO_ERROR))
1151 return -EIO;
1152
1153 rc = 0;
1154
1155 switch (cmd) {
1156 case TIOCGSERIAL:
1157 rc = stl_getserial(portp, argp);
1158 break;
1159 case TIOCSSERIAL:
1160 rc = stl_setserial(tty, argp);
1161 break;
1162 case COM_GETPORTSTATS:
1163 rc = stl_getportstats(tty, portp, argp);
1164 break;
1165 case COM_CLRPORTSTATS:
1166 rc = stl_clrportstats(portp, argp);
1167 break;
1168 case TIOCSERCONFIG:
1169 case TIOCSERGWILD:
1170 case TIOCSERSWILD:
1171 case TIOCSERGETLSR:
1172 case TIOCSERGSTRUCT:
1173 case TIOCSERGETMULTI:
1174 case TIOCSERSETMULTI:
1175 default:
1176 rc = -ENOIOCTLCMD;
1177 break;
1178 }
1179 return rc;
1180}
1181
1182
1183
1184
1185
1186
1187
1188static void stl_start(struct tty_struct *tty)
1189{
1190 struct stlport *portp;
1191
1192 pr_debug("stl_start(tty=%p)\n", tty);
1193
1194 portp = tty->driver_data;
1195 if (portp == NULL)
1196 return;
1197 stl_startrxtx(portp, -1, 1);
1198}
1199
1200
1201
1202static void stl_settermios(struct tty_struct *tty, struct ktermios *old)
1203{
1204 struct stlport *portp;
1205 struct ktermios *tiosp;
1206
1207 pr_debug("stl_settermios(tty=%p,old=%p)\n", tty, old);
1208
1209 portp = tty->driver_data;
1210 if (portp == NULL)
1211 return;
1212
1213 tiosp = tty->termios;
1214 if ((tiosp->c_cflag == old->c_cflag) &&
1215 (tiosp->c_iflag == old->c_iflag))
1216 return;
1217
1218 stl_setport(portp, tiosp);
1219 stl_setsignals(portp, ((tiosp->c_cflag & (CBAUD & ~CBAUDEX)) ? 1 : 0),
1220 -1);
1221 if ((old->c_cflag & CRTSCTS) && ((tiosp->c_cflag & CRTSCTS) == 0)) {
1222 tty->hw_stopped = 0;
1223 stl_start(tty);
1224 }
1225 if (((old->c_cflag & CLOCAL) == 0) && (tiosp->c_cflag & CLOCAL))
1226 wake_up_interruptible(&portp->port.open_wait);
1227}
1228
1229
1230
1231
1232
1233
1234
1235
1236static void stl_throttle(struct tty_struct *tty)
1237{
1238 struct stlport *portp;
1239
1240 pr_debug("stl_throttle(tty=%p)\n", tty);
1241
1242 portp = tty->driver_data;
1243 if (portp == NULL)
1244 return;
1245 stl_flowctrl(portp, 0);
1246}
1247
1248
1249
1250
1251
1252
1253
1254static void stl_unthrottle(struct tty_struct *tty)
1255{
1256 struct stlport *portp;
1257
1258 pr_debug("stl_unthrottle(tty=%p)\n", tty);
1259
1260 portp = tty->driver_data;
1261 if (portp == NULL)
1262 return;
1263 stl_flowctrl(portp, 1);
1264}
1265
1266
1267
1268
1269
1270
1271
1272
1273static void stl_stop(struct tty_struct *tty)
1274{
1275 struct stlport *portp;
1276
1277 pr_debug("stl_stop(tty=%p)\n", tty);
1278
1279 portp = tty->driver_data;
1280 if (portp == NULL)
1281 return;
1282 stl_startrxtx(portp, -1, 0);
1283}
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293static void stl_hangup(struct tty_struct *tty)
1294{
1295 struct stlport *portp = tty->driver_data;
1296 pr_debug("stl_hangup(tty=%p)\n", tty);
1297
1298 if (portp == NULL)
1299 return;
1300 tty_port_hangup(&portp->port);
1301}
1302
1303
1304
1305static int stl_breakctl(struct tty_struct *tty, int state)
1306{
1307 struct stlport *portp;
1308
1309 pr_debug("stl_breakctl(tty=%p,state=%d)\n", tty, state);
1310
1311 portp = tty->driver_data;
1312 if (portp == NULL)
1313 return -EINVAL;
1314
1315 stl_sendbreak(portp, ((state == -1) ? 1 : 2));
1316 return 0;
1317}
1318
1319
1320
1321static void stl_sendxchar(struct tty_struct *tty, char ch)
1322{
1323 struct stlport *portp;
1324
1325 pr_debug("stl_sendxchar(tty=%p,ch=%x)\n", tty, ch);
1326
1327 portp = tty->driver_data;
1328 if (portp == NULL)
1329 return;
1330
1331 if (ch == STOP_CHAR(tty))
1332 stl_sendflow(portp, 0);
1333 else if (ch == START_CHAR(tty))
1334 stl_sendflow(portp, 1);
1335 else
1336 stl_putchar(tty, ch);
1337}
1338
1339static void stl_portinfo(struct seq_file *m, struct stlport *portp, int portnr)
1340{
1341 int sigs;
1342 char sep;
1343
1344 seq_printf(m, "%d: uart:%s tx:%d rx:%d",
1345 portnr, (portp->hwid == 1) ? "SC26198" : "CD1400",
1346 (int) portp->stats.txtotal, (int) portp->stats.rxtotal);
1347
1348 if (portp->stats.rxframing)
1349 seq_printf(m, " fe:%d", (int) portp->stats.rxframing);
1350 if (portp->stats.rxparity)
1351 seq_printf(m, " pe:%d", (int) portp->stats.rxparity);
1352 if (portp->stats.rxbreaks)
1353 seq_printf(m, " brk:%d", (int) portp->stats.rxbreaks);
1354 if (portp->stats.rxoverrun)
1355 seq_printf(m, " oe:%d", (int) portp->stats.rxoverrun);
1356
1357 sigs = stl_getsignals(portp);
1358 sep = ' ';
1359 if (sigs & TIOCM_RTS) {
1360 seq_printf(m, "%c%s", sep, "RTS");
1361 sep = '|';
1362 }
1363 if (sigs & TIOCM_CTS) {
1364 seq_printf(m, "%c%s", sep, "CTS");
1365 sep = '|';
1366 }
1367 if (sigs & TIOCM_DTR) {
1368 seq_printf(m, "%c%s", sep, "DTR");
1369 sep = '|';
1370 }
1371 if (sigs & TIOCM_CD) {
1372 seq_printf(m, "%c%s", sep, "DCD");
1373 sep = '|';
1374 }
1375 if (sigs & TIOCM_DSR) {
1376 seq_printf(m, "%c%s", sep, "DSR");
1377 sep = '|';
1378 }
1379 seq_putc(m, '\n');
1380}
1381
1382
1383
1384
1385
1386
1387
1388static int stl_proc_show(struct seq_file *m, void *v)
1389{
1390 struct stlbrd *brdp;
1391 struct stlpanel *panelp;
1392 struct stlport *portp;
1393 unsigned int brdnr, panelnr, portnr;
1394 int totalport;
1395
1396 totalport = 0;
1397
1398 seq_printf(m, "%s: version %s\n", stl_drvtitle, stl_drvversion);
1399
1400
1401
1402
1403
1404 for (brdnr = 0; brdnr < stl_nrbrds; brdnr++) {
1405 brdp = stl_brds[brdnr];
1406 if (brdp == NULL)
1407 continue;
1408 if (brdp->state == 0)
1409 continue;
1410
1411 totalport = brdnr * STL_MAXPORTS;
1412 for (panelnr = 0; panelnr < brdp->nrpanels; panelnr++) {
1413 panelp = brdp->panels[panelnr];
1414 if (panelp == NULL)
1415 continue;
1416
1417 for (portnr = 0; portnr < panelp->nrports; portnr++,
1418 totalport++) {
1419 portp = panelp->ports[portnr];
1420 if (portp == NULL)
1421 continue;
1422 stl_portinfo(m, portp, totalport);
1423 }
1424 }
1425 }
1426 return 0;
1427}
1428
1429static int stl_proc_open(struct inode *inode, struct file *file)
1430{
1431 return single_open(file, stl_proc_show, NULL);
1432}
1433
1434static const struct file_operations stl_proc_fops = {
1435 .owner = THIS_MODULE,
1436 .open = stl_proc_open,
1437 .read = seq_read,
1438 .llseek = seq_lseek,
1439 .release = single_release,
1440};
1441
1442
1443
1444
1445
1446
1447
1448
1449static irqreturn_t stl_intr(int irq, void *dev_id)
1450{
1451 struct stlbrd *brdp = dev_id;
1452
1453 pr_debug("stl_intr(brdp=%p,irq=%d)\n", brdp, brdp->irq);
1454
1455 return IRQ_RETVAL((* brdp->isr)(brdp));
1456}
1457
1458
1459
1460
1461
1462
1463
1464static int stl_eiointr(struct stlbrd *brdp)
1465{
1466 struct stlpanel *panelp;
1467 unsigned int iobase;
1468 int handled = 0;
1469
1470 spin_lock(&brd_lock);
1471 panelp = brdp->panels[0];
1472 iobase = panelp->iobase;
1473 while (inb(brdp->iostatus) & EIO_INTRPEND) {
1474 handled = 1;
1475 (* panelp->isr)(panelp, iobase);
1476 }
1477 spin_unlock(&brd_lock);
1478 return handled;
1479}
1480
1481
1482
1483
1484
1485
1486
1487static int stl_echatintr(struct stlbrd *brdp)
1488{
1489 struct stlpanel *panelp;
1490 unsigned int ioaddr, bnknr;
1491 int handled = 0;
1492
1493 outb((brdp->ioctrlval | ECH_BRDENABLE), brdp->ioctrl);
1494
1495 while (inb(brdp->iostatus) & ECH_INTRPEND) {
1496 handled = 1;
1497 for (bnknr = 0; bnknr < brdp->nrbnks; bnknr++) {
1498 ioaddr = brdp->bnkstataddr[bnknr];
1499 if (inb(ioaddr) & ECH_PNLINTRPEND) {
1500 panelp = brdp->bnk2panel[bnknr];
1501 (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1502 }
1503 }
1504 }
1505
1506 outb((brdp->ioctrlval | ECH_BRDDISABLE), brdp->ioctrl);
1507
1508 return handled;
1509}
1510
1511
1512
1513
1514
1515
1516
1517static int stl_echmcaintr(struct stlbrd *brdp)
1518{
1519 struct stlpanel *panelp;
1520 unsigned int ioaddr, bnknr;
1521 int handled = 0;
1522
1523 while (inb(brdp->iostatus) & ECH_INTRPEND) {
1524 handled = 1;
1525 for (bnknr = 0; bnknr < brdp->nrbnks; bnknr++) {
1526 ioaddr = brdp->bnkstataddr[bnknr];
1527 if (inb(ioaddr) & ECH_PNLINTRPEND) {
1528 panelp = brdp->bnk2panel[bnknr];
1529 (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1530 }
1531 }
1532 }
1533 return handled;
1534}
1535
1536
1537
1538
1539
1540
1541
1542static int stl_echpciintr(struct stlbrd *brdp)
1543{
1544 struct stlpanel *panelp;
1545 unsigned int ioaddr, bnknr, recheck;
1546 int handled = 0;
1547
1548 while (1) {
1549 recheck = 0;
1550 for (bnknr = 0; bnknr < brdp->nrbnks; bnknr++) {
1551 outb(brdp->bnkpageaddr[bnknr], brdp->ioctrl);
1552 ioaddr = brdp->bnkstataddr[bnknr];
1553 if (inb(ioaddr) & ECH_PNLINTRPEND) {
1554 panelp = brdp->bnk2panel[bnknr];
1555 (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1556 recheck++;
1557 handled = 1;
1558 }
1559 }
1560 if (! recheck)
1561 break;
1562 }
1563 return handled;
1564}
1565
1566
1567
1568
1569
1570
1571
1572static int stl_echpci64intr(struct stlbrd *brdp)
1573{
1574 struct stlpanel *panelp;
1575 unsigned int ioaddr, bnknr;
1576 int handled = 0;
1577
1578 while (inb(brdp->ioctrl) & 0x1) {
1579 handled = 1;
1580 for (bnknr = 0; bnknr < brdp->nrbnks; bnknr++) {
1581 ioaddr = brdp->bnkstataddr[bnknr];
1582 if (inb(ioaddr) & ECH_PNLINTRPEND) {
1583 panelp = brdp->bnk2panel[bnknr];
1584 (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1585 }
1586 }
1587 }
1588
1589 return handled;
1590}
1591
1592
1593
1594
1595
1596
1597
1598static int __devinit stl_initports(struct stlbrd *brdp, struct stlpanel *panelp)
1599{
1600 struct stlport *portp;
1601 unsigned int i;
1602 int chipmask;
1603
1604 pr_debug("stl_initports(brdp=%p,panelp=%p)\n", brdp, panelp);
1605
1606 chipmask = stl_panelinit(brdp, panelp);
1607
1608
1609
1610
1611
1612 for (i = 0; i < panelp->nrports; i++) {
1613 portp = kzalloc(sizeof(struct stlport), GFP_KERNEL);
1614 if (!portp) {
1615 printk("STALLION: failed to allocate memory "
1616 "(size=%Zd)\n", sizeof(struct stlport));
1617 break;
1618 }
1619 tty_port_init(&portp->port);
1620 portp->port.ops = &stl_port_ops;
1621 portp->magic = STL_PORTMAGIC;
1622 portp->portnr = i;
1623 portp->brdnr = panelp->brdnr;
1624 portp->panelnr = panelp->panelnr;
1625 portp->uartp = panelp->uartp;
1626 portp->clk = brdp->clk;
1627 portp->baud_base = STL_BAUDBASE;
1628 portp->close_delay = STL_CLOSEDELAY;
1629 portp->closing_wait = 30 * HZ;
1630 init_waitqueue_head(&portp->port.open_wait);
1631 init_waitqueue_head(&portp->port.close_wait);
1632 portp->stats.brd = portp->brdnr;
1633 portp->stats.panel = portp->panelnr;
1634 portp->stats.port = portp->portnr;
1635 panelp->ports[i] = portp;
1636 stl_portinit(brdp, panelp, portp);
1637 }
1638
1639 return 0;
1640}
1641
1642static void stl_cleanup_panels(struct stlbrd *brdp)
1643{
1644 struct stlpanel *panelp;
1645 struct stlport *portp;
1646 unsigned int j, k;
1647 struct tty_struct *tty;
1648
1649 for (j = 0; j < STL_MAXPANELS; j++) {
1650 panelp = brdp->panels[j];
1651 if (panelp == NULL)
1652 continue;
1653 for (k = 0; k < STL_PORTSPERPANEL; k++) {
1654 portp = panelp->ports[k];
1655 if (portp == NULL)
1656 continue;
1657 tty = tty_port_tty_get(&portp->port);
1658 if (tty != NULL) {
1659 stl_hangup(tty);
1660 tty_kref_put(tty);
1661 }
1662 kfree(portp->tx.buf);
1663 kfree(portp);
1664 }
1665 kfree(panelp);
1666 }
1667}
1668
1669
1670
1671
1672
1673
1674
1675static int __devinit stl_initeio(struct stlbrd *brdp)
1676{
1677 struct stlpanel *panelp;
1678 unsigned int status;
1679 char *name;
1680 int retval;
1681
1682 pr_debug("stl_initeio(brdp=%p)\n", brdp);
1683
1684 brdp->ioctrl = brdp->ioaddr1 + 1;
1685 brdp->iostatus = brdp->ioaddr1 + 2;
1686
1687 status = inb(brdp->iostatus);
1688 if ((status & EIO_IDBITMASK) == EIO_MK3)
1689 brdp->ioctrl++;
1690
1691
1692
1693
1694
1695 if (brdp->brdtype == BRD_EASYIOPCI) {
1696 brdp->iosize1 = 0x80;
1697 brdp->iosize2 = 0x80;
1698 name = "serial(EIO-PCI)";
1699 outb(0x41, (brdp->ioaddr2 + 0x4c));
1700 } else {
1701 brdp->iosize1 = 8;
1702 name = "serial(EIO)";
1703 if ((brdp->irq < 0) || (brdp->irq > 15) ||
1704 (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) {
1705 printk("STALLION: invalid irq=%d for brd=%d\n",
1706 brdp->irq, brdp->brdnr);
1707 retval = -EINVAL;
1708 goto err;
1709 }
1710 outb((stl_vecmap[brdp->irq] | EIO_0WS |
1711 ((brdp->irqtype) ? EIO_INTLEVEL : EIO_INTEDGE)),
1712 brdp->ioctrl);
1713 }
1714
1715 retval = -EBUSY;
1716 if (!request_region(brdp->ioaddr1, brdp->iosize1, name)) {
1717 printk(KERN_WARNING "STALLION: Warning, board %d I/O address "
1718 "%x conflicts with another device\n", brdp->brdnr,
1719 brdp->ioaddr1);
1720 goto err;
1721 }
1722
1723 if (brdp->iosize2 > 0)
1724 if (!request_region(brdp->ioaddr2, brdp->iosize2, name)) {
1725 printk(KERN_WARNING "STALLION: Warning, board %d I/O "
1726 "address %x conflicts with another device\n",
1727 brdp->brdnr, brdp->ioaddr2);
1728 printk(KERN_WARNING "STALLION: Warning, also "
1729 "releasing board %d I/O address %x \n",
1730 brdp->brdnr, brdp->ioaddr1);
1731 goto err_rel1;
1732 }
1733
1734
1735
1736
1737 brdp->clk = CD1400_CLK;
1738 brdp->isr = stl_eiointr;
1739
1740 retval = -ENODEV;
1741 switch (status & EIO_IDBITMASK) {
1742 case EIO_8PORTM:
1743 brdp->clk = CD1400_CLK8M;
1744
1745 case EIO_8PORTRS:
1746 case EIO_8PORTDI:
1747 brdp->nrports = 8;
1748 break;
1749 case EIO_4PORTRS:
1750 brdp->nrports = 4;
1751 break;
1752 case EIO_MK3:
1753 switch (status & EIO_BRDMASK) {
1754 case ID_BRD4:
1755 brdp->nrports = 4;
1756 break;
1757 case ID_BRD8:
1758 brdp->nrports = 8;
1759 break;
1760 case ID_BRD16:
1761 brdp->nrports = 16;
1762 break;
1763 default:
1764 goto err_rel2;
1765 }
1766 break;
1767 default:
1768 goto err_rel2;
1769 }
1770
1771
1772
1773
1774
1775
1776 panelp = kzalloc(sizeof(struct stlpanel), GFP_KERNEL);
1777 if (!panelp) {
1778 printk(KERN_WARNING "STALLION: failed to allocate memory "
1779 "(size=%Zd)\n", sizeof(struct stlpanel));
1780 retval = -ENOMEM;
1781 goto err_rel2;
1782 }
1783
1784 panelp->magic = STL_PANELMAGIC;
1785 panelp->brdnr = brdp->brdnr;
1786 panelp->panelnr = 0;
1787 panelp->nrports = brdp->nrports;
1788 panelp->iobase = brdp->ioaddr1;
1789 panelp->hwid = status;
1790 if ((status & EIO_IDBITMASK) == EIO_MK3) {
1791 panelp->uartp = &stl_sc26198uart;
1792 panelp->isr = stl_sc26198intr;
1793 } else {
1794 panelp->uartp = &stl_cd1400uart;
1795 panelp->isr = stl_cd1400eiointr;
1796 }
1797
1798 brdp->panels[0] = panelp;
1799 brdp->nrpanels = 1;
1800 brdp->state |= BRD_FOUND;
1801 brdp->hwid = status;
1802 if (request_irq(brdp->irq, stl_intr, IRQF_SHARED, name, brdp) != 0) {
1803 printk("STALLION: failed to register interrupt "
1804 "routine for %s irq=%d\n", name, brdp->irq);
1805 retval = -ENODEV;
1806 goto err_fr;
1807 }
1808
1809 return 0;
1810err_fr:
1811 stl_cleanup_panels(brdp);
1812err_rel2:
1813 if (brdp->iosize2 > 0)
1814 release_region(brdp->ioaddr2, brdp->iosize2);
1815err_rel1:
1816 release_region(brdp->ioaddr1, brdp->iosize1);
1817err:
1818 return retval;
1819}
1820
1821
1822
1823
1824
1825
1826
1827
1828static int __devinit stl_initech(struct stlbrd *brdp)
1829{
1830 struct stlpanel *panelp;
1831 unsigned int status, nxtid, ioaddr, conflict, panelnr, banknr, i;
1832 int retval;
1833 char *name;
1834
1835 pr_debug("stl_initech(brdp=%p)\n", brdp);
1836
1837 status = 0;
1838 conflict = 0;
1839
1840
1841
1842
1843
1844
1845 switch (brdp->brdtype) {
1846
1847 case BRD_ECH:
1848 brdp->isr = stl_echatintr;
1849 brdp->ioctrl = brdp->ioaddr1 + 1;
1850 brdp->iostatus = brdp->ioaddr1 + 1;
1851 status = inb(brdp->iostatus);
1852 if ((status & ECH_IDBITMASK) != ECH_ID) {
1853 retval = -ENODEV;
1854 goto err;
1855 }
1856 if ((brdp->irq < 0) || (brdp->irq > 15) ||
1857 (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) {
1858 printk("STALLION: invalid irq=%d for brd=%d\n",
1859 brdp->irq, brdp->brdnr);
1860 retval = -EINVAL;
1861 goto err;
1862 }
1863 status = ((brdp->ioaddr2 & ECH_ADDR2MASK) >> 1);
1864 status |= (stl_vecmap[brdp->irq] << 1);
1865 outb((status | ECH_BRDRESET), brdp->ioaddr1);
1866 brdp->ioctrlval = ECH_INTENABLE |
1867 ((brdp->irqtype) ? ECH_INTLEVEL : ECH_INTEDGE);
1868 for (i = 0; i < 10; i++)
1869 outb((brdp->ioctrlval | ECH_BRDENABLE), brdp->ioctrl);
1870 brdp->iosize1 = 2;
1871 brdp->iosize2 = 32;
1872 name = "serial(EC8/32)";
1873 outb(status, brdp->ioaddr1);
1874 break;
1875
1876 case BRD_ECHMC:
1877 brdp->isr = stl_echmcaintr;
1878 brdp->ioctrl = brdp->ioaddr1 + 0x20;
1879 brdp->iostatus = brdp->ioctrl;
1880 status = inb(brdp->iostatus);
1881 if ((status & ECH_IDBITMASK) != ECH_ID) {
1882 retval = -ENODEV;
1883 goto err;
1884 }
1885 if ((brdp->irq < 0) || (brdp->irq > 15) ||
1886 (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) {
1887 printk("STALLION: invalid irq=%d for brd=%d\n",
1888 brdp->irq, brdp->brdnr);
1889 retval = -EINVAL;
1890 goto err;
1891 }
1892 outb(ECHMC_BRDRESET, brdp->ioctrl);
1893 outb(ECHMC_INTENABLE, brdp->ioctrl);
1894 brdp->iosize1 = 64;
1895 name = "serial(EC8/32-MC)";
1896 break;
1897
1898 case BRD_ECHPCI:
1899 brdp->isr = stl_echpciintr;
1900 brdp->ioctrl = brdp->ioaddr1 + 2;
1901 brdp->iosize1 = 4;
1902 brdp->iosize2 = 8;
1903 name = "serial(EC8/32-PCI)";
1904 break;
1905
1906 case BRD_ECH64PCI:
1907 brdp->isr = stl_echpci64intr;
1908 brdp->ioctrl = brdp->ioaddr2 + 0x40;
1909 outb(0x43, (brdp->ioaddr1 + 0x4c));
1910 brdp->iosize1 = 0x80;
1911 brdp->iosize2 = 0x80;
1912 name = "serial(EC8/64-PCI)";
1913 break;
1914
1915 default:
1916 printk("STALLION: unknown board type=%d\n", brdp->brdtype);
1917 retval = -EINVAL;
1918 goto err;
1919 }
1920
1921
1922
1923
1924
1925 retval = -EBUSY;
1926 if (!request_region(brdp->ioaddr1, brdp->iosize1, name)) {
1927 printk(KERN_WARNING "STALLION: Warning, board %d I/O address "
1928 "%x conflicts with another device\n", brdp->brdnr,
1929 brdp->ioaddr1);
1930 goto err;
1931 }
1932
1933 if (brdp->iosize2 > 0)
1934 if (!request_region(brdp->ioaddr2, brdp->iosize2, name)) {
1935 printk(KERN_WARNING "STALLION: Warning, board %d I/O "
1936 "address %x conflicts with another device\n",
1937 brdp->brdnr, brdp->ioaddr2);
1938 printk(KERN_WARNING "STALLION: Warning, also "
1939 "releasing board %d I/O address %x \n",
1940 brdp->brdnr, brdp->ioaddr1);
1941 goto err_rel1;
1942 }
1943
1944
1945
1946
1947
1948 brdp->clk = CD1400_CLK;
1949 brdp->hwid = status;
1950
1951 ioaddr = brdp->ioaddr2;
1952 banknr = 0;
1953 panelnr = 0;
1954 nxtid = 0;
1955
1956 for (i = 0; i < STL_MAXPANELS; i++) {
1957 if (brdp->brdtype == BRD_ECHPCI) {
1958 outb(nxtid, brdp->ioctrl);
1959 ioaddr = brdp->ioaddr2;
1960 }
1961 status = inb(ioaddr + ECH_PNLSTATUS);
1962 if ((status & ECH_PNLIDMASK) != nxtid)
1963 break;
1964 panelp = kzalloc(sizeof(struct stlpanel), GFP_KERNEL);
1965 if (!panelp) {
1966 printk("STALLION: failed to allocate memory "
1967 "(size=%Zd)\n", sizeof(struct stlpanel));
1968 retval = -ENOMEM;
1969 goto err_fr;
1970 }
1971 panelp->magic = STL_PANELMAGIC;
1972 panelp->brdnr = brdp->brdnr;
1973 panelp->panelnr = panelnr;
1974 panelp->iobase = ioaddr;
1975 panelp->pagenr = nxtid;
1976 panelp->hwid = status;
1977 brdp->bnk2panel[banknr] = panelp;
1978 brdp->bnkpageaddr[banknr] = nxtid;
1979 brdp->bnkstataddr[banknr++] = ioaddr + ECH_PNLSTATUS;
1980
1981 if (status & ECH_PNLXPID) {
1982 panelp->uartp = &stl_sc26198uart;
1983 panelp->isr = stl_sc26198intr;
1984 if (status & ECH_PNL16PORT) {
1985 panelp->nrports = 16;
1986 brdp->bnk2panel[banknr] = panelp;
1987 brdp->bnkpageaddr[banknr] = nxtid;
1988 brdp->bnkstataddr[banknr++] = ioaddr + 4 +
1989 ECH_PNLSTATUS;
1990 } else
1991 panelp->nrports = 8;
1992 } else {
1993 panelp->uartp = &stl_cd1400uart;
1994 panelp->isr = stl_cd1400echintr;
1995 if (status & ECH_PNL16PORT) {
1996 panelp->nrports = 16;
1997 panelp->ackmask = 0x80;
1998 if (brdp->brdtype != BRD_ECHPCI)
1999 ioaddr += EREG_BANKSIZE;
2000 brdp->bnk2panel[banknr] = panelp;
2001 brdp->bnkpageaddr[banknr] = ++nxtid;
2002 brdp->bnkstataddr[banknr++] = ioaddr +
2003 ECH_PNLSTATUS;
2004 } else {
2005 panelp->nrports = 8;
2006 panelp->ackmask = 0xc0;
2007 }
2008 }
2009
2010 nxtid++;
2011 ioaddr += EREG_BANKSIZE;
2012 brdp->nrports += panelp->nrports;
2013 brdp->panels[panelnr++] = panelp;
2014 if ((brdp->brdtype != BRD_ECHPCI) &&
2015 (ioaddr >= (brdp->ioaddr2 + brdp->iosize2))) {
2016 retval = -EINVAL;
2017 goto err_fr;
2018 }
2019 }
2020
2021 brdp->nrpanels = panelnr;
2022 brdp->nrbnks = banknr;
2023 if (brdp->brdtype == BRD_ECH)
2024 outb((brdp->ioctrlval | ECH_BRDDISABLE), brdp->ioctrl);
2025
2026 brdp->state |= BRD_FOUND;
2027 if (request_irq(brdp->irq, stl_intr, IRQF_SHARED, name, brdp) != 0) {
2028 printk("STALLION: failed to register interrupt "
2029 "routine for %s irq=%d\n", name, brdp->irq);
2030 retval = -ENODEV;
2031 goto err_fr;
2032 }
2033
2034 return 0;
2035err_fr:
2036 stl_cleanup_panels(brdp);
2037 if (brdp->iosize2 > 0)
2038 release_region(brdp->ioaddr2, brdp->iosize2);
2039err_rel1:
2040 release_region(brdp->ioaddr1, brdp->iosize1);
2041err:
2042 return retval;
2043}
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054static int __devinit stl_brdinit(struct stlbrd *brdp)
2055{
2056 int i, retval;
2057
2058 pr_debug("stl_brdinit(brdp=%p)\n", brdp);
2059
2060 switch (brdp->brdtype) {
2061 case BRD_EASYIO:
2062 case BRD_EASYIOPCI:
2063 retval = stl_initeio(brdp);
2064 if (retval)
2065 goto err;
2066 break;
2067 case BRD_ECH:
2068 case BRD_ECHMC:
2069 case BRD_ECHPCI:
2070 case BRD_ECH64PCI:
2071 retval = stl_initech(brdp);
2072 if (retval)
2073 goto err;
2074 break;
2075 default:
2076 printk("STALLION: board=%d is unknown board type=%d\n",
2077 brdp->brdnr, brdp->brdtype);
2078 retval = -ENODEV;
2079 goto err;
2080 }
2081
2082 if ((brdp->state & BRD_FOUND) == 0) {
2083 printk("STALLION: %s board not found, board=%d io=%x irq=%d\n",
2084 stl_brdnames[brdp->brdtype], brdp->brdnr,
2085 brdp->ioaddr1, brdp->irq);
2086 goto err_free;
2087 }
2088
2089 for (i = 0; i < STL_MAXPANELS; i++)
2090 if (brdp->panels[i] != NULL)
2091 stl_initports(brdp, brdp->panels[i]);
2092
2093 printk("STALLION: %s found, board=%d io=%x irq=%d "
2094 "nrpanels=%d nrports=%d\n", stl_brdnames[brdp->brdtype],
2095 brdp->brdnr, brdp->ioaddr1, brdp->irq, brdp->nrpanels,
2096 brdp->nrports);
2097
2098 return 0;
2099err_free:
2100 free_irq(brdp->irq, brdp);
2101
2102 stl_cleanup_panels(brdp);
2103
2104 release_region(brdp->ioaddr1, brdp->iosize1);
2105 if (brdp->iosize2 > 0)
2106 release_region(brdp->ioaddr2, brdp->iosize2);
2107err:
2108 return retval;
2109}
2110
2111
2112
2113
2114
2115
2116
2117static int __devinit stl_getbrdnr(void)
2118{
2119 unsigned int i;
2120
2121 for (i = 0; i < STL_MAXBRDS; i++)
2122 if (stl_brds[i] == NULL) {
2123 if (i >= stl_nrbrds)
2124 stl_nrbrds = i + 1;
2125 return i;
2126 }
2127
2128 return -1;
2129}
2130
2131
2132
2133
2134
2135
2136
2137
2138static int __devinit stl_pciprobe(struct pci_dev *pdev,
2139 const struct pci_device_id *ent)
2140{
2141 struct stlbrd *brdp;
2142 unsigned int i, brdtype = ent->driver_data;
2143 int brdnr, retval = -ENODEV;
2144
2145 if ((pdev->class >> 8) == PCI_CLASS_STORAGE_IDE)
2146 goto err;
2147
2148 retval = pci_enable_device(pdev);
2149 if (retval)
2150 goto err;
2151 brdp = stl_allocbrd();
2152 if (brdp == NULL) {
2153 retval = -ENOMEM;
2154 goto err;
2155 }
2156 mutex_lock(&stl_brdslock);
2157 brdnr = stl_getbrdnr();
2158 if (brdnr < 0) {
2159 dev_err(&pdev->dev, "too many boards found, "
2160 "maximum supported %d\n", STL_MAXBRDS);
2161 mutex_unlock(&stl_brdslock);
2162 retval = -ENODEV;
2163 goto err_fr;
2164 }
2165 brdp->brdnr = (unsigned int)brdnr;
2166 stl_brds[brdp->brdnr] = brdp;
2167 mutex_unlock(&stl_brdslock);
2168
2169 brdp->brdtype = brdtype;
2170 brdp->state |= STL_PROBED;
2171
2172
2173
2174
2175
2176 switch (brdtype) {
2177 case BRD_ECHPCI:
2178 brdp->ioaddr2 = pci_resource_start(pdev, 0);
2179 brdp->ioaddr1 = pci_resource_start(pdev, 1);
2180 break;
2181 case BRD_ECH64PCI:
2182 brdp->ioaddr2 = pci_resource_start(pdev, 2);
2183 brdp->ioaddr1 = pci_resource_start(pdev, 1);
2184 break;
2185 case BRD_EASYIOPCI:
2186 brdp->ioaddr1 = pci_resource_start(pdev, 2);
2187 brdp->ioaddr2 = pci_resource_start(pdev, 1);
2188 break;
2189 default:
2190 dev_err(&pdev->dev, "unknown PCI board type=%u\n", brdtype);
2191 break;
2192 }
2193
2194 brdp->irq = pdev->irq;
2195 retval = stl_brdinit(brdp);
2196 if (retval)
2197 goto err_null;
2198
2199 pci_set_drvdata(pdev, brdp);
2200
2201 for (i = 0; i < brdp->nrports; i++)
2202 tty_register_device(stl_serial,
2203 brdp->brdnr * STL_MAXPORTS + i, &pdev->dev);
2204
2205 return 0;
2206err_null:
2207 stl_brds[brdp->brdnr] = NULL;
2208err_fr:
2209 kfree(brdp);
2210err:
2211 return retval;
2212}
2213
2214static void __devexit stl_pciremove(struct pci_dev *pdev)
2215{
2216 struct stlbrd *brdp = pci_get_drvdata(pdev);
2217 unsigned int i;
2218
2219 free_irq(brdp->irq, brdp);
2220
2221 stl_cleanup_panels(brdp);
2222
2223 release_region(brdp->ioaddr1, brdp->iosize1);
2224 if (brdp->iosize2 > 0)
2225 release_region(brdp->ioaddr2, brdp->iosize2);
2226
2227 for (i = 0; i < brdp->nrports; i++)
2228 tty_unregister_device(stl_serial,
2229 brdp->brdnr * STL_MAXPORTS + i);
2230
2231 stl_brds[brdp->brdnr] = NULL;
2232 kfree(brdp);
2233}
2234
2235static struct pci_driver stl_pcidriver = {
2236 .name = "stallion",
2237 .id_table = stl_pcibrds,
2238 .probe = stl_pciprobe,
2239 .remove = __devexit_p(stl_pciremove)
2240};
2241
2242
2243
2244
2245
2246
2247
2248static int stl_getbrdstats(combrd_t __user *bp)
2249{
2250 combrd_t stl_brdstats;
2251 struct stlbrd *brdp;
2252 struct stlpanel *panelp;
2253 unsigned int i;
2254
2255 if (copy_from_user(&stl_brdstats, bp, sizeof(combrd_t)))
2256 return -EFAULT;
2257 if (stl_brdstats.brd >= STL_MAXBRDS)
2258 return -ENODEV;
2259 brdp = stl_brds[stl_brdstats.brd];
2260 if (brdp == NULL)
2261 return -ENODEV;
2262
2263 memset(&stl_brdstats, 0, sizeof(combrd_t));
2264 stl_brdstats.brd = brdp->brdnr;
2265 stl_brdstats.type = brdp->brdtype;
2266 stl_brdstats.hwid = brdp->hwid;
2267 stl_brdstats.state = brdp->state;
2268 stl_brdstats.ioaddr = brdp->ioaddr1;
2269 stl_brdstats.ioaddr2 = brdp->ioaddr2;
2270 stl_brdstats.irq = brdp->irq;
2271 stl_brdstats.nrpanels = brdp->nrpanels;
2272 stl_brdstats.nrports = brdp->nrports;
2273 for (i = 0; i < brdp->nrpanels; i++) {
2274 panelp = brdp->panels[i];
2275 stl_brdstats.panels[i].panel = i;
2276 stl_brdstats.panels[i].hwid = panelp->hwid;
2277 stl_brdstats.panels[i].nrports = panelp->nrports;
2278 }
2279
2280 return copy_to_user(bp, &stl_brdstats, sizeof(combrd_t)) ? -EFAULT : 0;
2281}
2282
2283
2284
2285
2286
2287
2288
2289static struct stlport *stl_getport(int brdnr, int panelnr, int portnr)
2290{
2291 struct stlbrd *brdp;
2292 struct stlpanel *panelp;
2293
2294 if (brdnr < 0 || brdnr >= STL_MAXBRDS)
2295 return NULL;
2296 brdp = stl_brds[brdnr];
2297 if (brdp == NULL)
2298 return NULL;
2299 if (panelnr < 0 || (unsigned int)panelnr >= brdp->nrpanels)
2300 return NULL;
2301 panelp = brdp->panels[panelnr];
2302 if (panelp == NULL)
2303 return NULL;
2304 if (portnr < 0 || (unsigned int)portnr >= panelp->nrports)
2305 return NULL;
2306 return panelp->ports[portnr];
2307}
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317static int stl_getportstats(struct tty_struct *tty, struct stlport *portp, comstats_t __user *cp)
2318{
2319 comstats_t stl_comstats;
2320 unsigned char *head, *tail;
2321 unsigned long flags;
2322
2323 if (!portp) {
2324 if (copy_from_user(&stl_comstats, cp, sizeof(comstats_t)))
2325 return -EFAULT;
2326 portp = stl_getport(stl_comstats.brd, stl_comstats.panel,
2327 stl_comstats.port);
2328 if (portp == NULL)
2329 return -ENODEV;
2330 }
2331
2332 mutex_lock(&portp->port.mutex);
2333 portp->stats.state = portp->istate;
2334 portp->stats.flags = portp->port.flags;
2335 portp->stats.hwid = portp->hwid;
2336
2337 portp->stats.ttystate = 0;
2338 portp->stats.cflags = 0;
2339 portp->stats.iflags = 0;
2340 portp->stats.oflags = 0;
2341 portp->stats.lflags = 0;
2342 portp->stats.rxbuffered = 0;
2343
2344 spin_lock_irqsave(&stallion_lock, flags);
2345 if (tty != NULL && portp->port.tty == tty) {
2346 portp->stats.ttystate = tty->flags;
2347
2348 portp->stats.rxbuffered = 1;
2349 if (tty->termios != NULL) {
2350 portp->stats.cflags = tty->termios->c_cflag;
2351 portp->stats.iflags = tty->termios->c_iflag;
2352 portp->stats.oflags = tty->termios->c_oflag;
2353 portp->stats.lflags = tty->termios->c_lflag;
2354 }
2355 }
2356 spin_unlock_irqrestore(&stallion_lock, flags);
2357
2358 head = portp->tx.head;
2359 tail = portp->tx.tail;
2360 portp->stats.txbuffered = (head >= tail) ? (head - tail) :
2361 (STL_TXBUFSIZE - (tail - head));
2362
2363 portp->stats.signals = (unsigned long) stl_getsignals(portp);
2364 mutex_unlock(&portp->port.mutex);
2365
2366 return copy_to_user(cp, &portp->stats,
2367 sizeof(comstats_t)) ? -EFAULT : 0;
2368}
2369
2370
2371
2372
2373
2374
2375
2376static int stl_clrportstats(struct stlport *portp, comstats_t __user *cp)
2377{
2378 comstats_t stl_comstats;
2379
2380 if (!portp) {
2381 if (copy_from_user(&stl_comstats, cp, sizeof(comstats_t)))
2382 return -EFAULT;
2383 portp = stl_getport(stl_comstats.brd, stl_comstats.panel,
2384 stl_comstats.port);
2385 if (portp == NULL)
2386 return -ENODEV;
2387 }
2388
2389 mutex_lock(&portp->port.mutex);
2390 memset(&portp->stats, 0, sizeof(comstats_t));
2391 portp->stats.brd = portp->brdnr;
2392 portp->stats.panel = portp->panelnr;
2393 portp->stats.port = portp->portnr;
2394 mutex_unlock(&portp->port.mutex);
2395 return copy_to_user(cp, &portp->stats,
2396 sizeof(comstats_t)) ? -EFAULT : 0;
2397}
2398
2399
2400
2401
2402
2403
2404
2405static int stl_getportstruct(struct stlport __user *arg)
2406{
2407 struct stlport stl_dummyport;
2408 struct stlport *portp;
2409
2410 if (copy_from_user(&stl_dummyport, arg, sizeof(struct stlport)))
2411 return -EFAULT;
2412 portp = stl_getport(stl_dummyport.brdnr, stl_dummyport.panelnr,
2413 stl_dummyport.portnr);
2414 if (!portp)
2415 return -ENODEV;
2416 return copy_to_user(arg, portp, sizeof(struct stlport)) ? -EFAULT : 0;
2417}
2418
2419
2420
2421
2422
2423
2424
2425static int stl_getbrdstruct(struct stlbrd __user *arg)
2426{
2427 struct stlbrd stl_dummybrd;
2428 struct stlbrd *brdp;
2429
2430 if (copy_from_user(&stl_dummybrd, arg, sizeof(struct stlbrd)))
2431 return -EFAULT;
2432 if (stl_dummybrd.brdnr >= STL_MAXBRDS)
2433 return -ENODEV;
2434 brdp = stl_brds[stl_dummybrd.brdnr];
2435 if (!brdp)
2436 return -ENODEV;
2437 return copy_to_user(arg, brdp, sizeof(struct stlbrd)) ? -EFAULT : 0;
2438}
2439
2440
2441
2442
2443
2444
2445
2446
2447
2448static long stl_memioctl(struct file *fp, unsigned int cmd, unsigned long arg)
2449{
2450 int brdnr, rc;
2451 void __user *argp = (void __user *)arg;
2452
2453 pr_debug("stl_memioctl(fp=%p,cmd=%x,arg=%lx)\n", fp, cmd,arg);
2454
2455 brdnr = iminor(fp->f_dentry->d_inode);
2456 if (brdnr >= STL_MAXBRDS)
2457 return -ENODEV;
2458 rc = 0;
2459
2460 switch (cmd) {
2461 case COM_GETPORTSTATS:
2462 rc = stl_getportstats(NULL, NULL, argp);
2463 break;
2464 case COM_CLRPORTSTATS:
2465 rc = stl_clrportstats(NULL, argp);
2466 break;
2467 case COM_GETBRDSTATS:
2468 rc = stl_getbrdstats(argp);
2469 break;
2470 case COM_READPORT:
2471 rc = stl_getportstruct(argp);
2472 break;
2473 case COM_READBOARD:
2474 rc = stl_getbrdstruct(argp);
2475 break;
2476 default:
2477 rc = -ENOIOCTLCMD;
2478 break;
2479 }
2480 return rc;
2481}
2482
2483static const struct tty_operations stl_ops = {
2484 .open = stl_open,
2485 .close = stl_close,
2486 .write = stl_write,
2487 .put_char = stl_putchar,
2488 .flush_chars = stl_flushchars,
2489 .write_room = stl_writeroom,
2490 .chars_in_buffer = stl_charsinbuffer,
2491 .ioctl = stl_ioctl,
2492 .set_termios = stl_settermios,
2493 .throttle = stl_throttle,
2494 .unthrottle = stl_unthrottle,
2495 .stop = stl_stop,
2496 .start = stl_start,
2497 .hangup = stl_hangup,
2498 .flush_buffer = stl_flushbuffer,
2499 .break_ctl = stl_breakctl,
2500 .wait_until_sent = stl_waituntilsent,
2501 .send_xchar = stl_sendxchar,
2502 .tiocmget = stl_tiocmget,
2503 .tiocmset = stl_tiocmset,
2504 .proc_fops = &stl_proc_fops,
2505};
2506
2507static const struct tty_port_operations stl_port_ops = {
2508 .carrier_raised = stl_carrier_raised,
2509 .dtr_rts = stl_dtr_rts,
2510 .activate = stl_activate,
2511 .shutdown = stl_shutdown,
2512};
2513
2514
2515
2516
2517
2518
2519
2520
2521
2522
2523
2524static int stl_cd1400getreg(struct stlport *portp, int regnr)
2525{
2526 outb((regnr + portp->uartaddr), portp->ioaddr);
2527 return inb(portp->ioaddr + EREG_DATA);
2528}
2529
2530static void stl_cd1400setreg(struct stlport *portp, int regnr, int value)
2531{
2532 outb(regnr + portp->uartaddr, portp->ioaddr);
2533 outb(value, portp->ioaddr + EREG_DATA);
2534}
2535
2536static int stl_cd1400updatereg(struct stlport *portp, int regnr, int value)
2537{
2538 outb(regnr + portp->uartaddr, portp->ioaddr);
2539 if (inb(portp->ioaddr + EREG_DATA) != value) {
2540 outb(value, portp->ioaddr + EREG_DATA);
2541 return 1;
2542 }
2543 return 0;
2544}
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554static int stl_cd1400panelinit(struct stlbrd *brdp, struct stlpanel *panelp)
2555{
2556 unsigned int gfrcr;
2557 int chipmask, i, j;
2558 int nrchips, uartaddr, ioaddr;
2559 unsigned long flags;
2560
2561 pr_debug("stl_panelinit(brdp=%p,panelp=%p)\n", brdp, panelp);
2562
2563 spin_lock_irqsave(&brd_lock, flags);
2564 BRDENABLE(panelp->brdnr, panelp->pagenr);
2565
2566
2567
2568
2569 chipmask = 0;
2570 nrchips = panelp->nrports / CD1400_PORTS;
2571 for (i = 0; i < nrchips; i++) {
2572 if (brdp->brdtype == BRD_ECHPCI) {
2573 outb((panelp->pagenr + (i >> 1)), brdp->ioctrl);
2574 ioaddr = panelp->iobase;
2575 } else
2576 ioaddr = panelp->iobase + (EREG_BANKSIZE * (i >> 1));
2577 uartaddr = (i & 0x01) ? 0x080 : 0;
2578 outb((GFRCR + uartaddr), ioaddr);
2579 outb(0, (ioaddr + EREG_DATA));
2580 outb((CCR + uartaddr), ioaddr);
2581 outb(CCR_RESETFULL, (ioaddr + EREG_DATA));
2582 outb(CCR_RESETFULL, (ioaddr + EREG_DATA));
2583 outb((GFRCR + uartaddr), ioaddr);
2584 for (j = 0; j < CCR_MAXWAIT; j++)
2585 if ((gfrcr = inb(ioaddr + EREG_DATA)) != 0)
2586 break;
2587
2588 if ((j >= CCR_MAXWAIT) || (gfrcr < 0x40) || (gfrcr > 0x60)) {
2589 printk("STALLION: cd1400 not responding, "
2590 "brd=%d panel=%d chip=%d\n",
2591 panelp->brdnr, panelp->panelnr, i);
2592 continue;
2593 }
2594 chipmask |= (0x1 << i);
2595 outb((PPR + uartaddr), ioaddr);
2596 outb(PPR_SCALAR, (ioaddr + EREG_DATA));
2597 }
2598
2599 BRDDISABLE(panelp->brdnr);
2600 spin_unlock_irqrestore(&brd_lock, flags);
2601 return chipmask;
2602}
2603
2604
2605
2606
2607
2608
2609
2610static void stl_cd1400portinit(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp)
2611{
2612 unsigned long flags;
2613 pr_debug("stl_cd1400portinit(brdp=%p,panelp=%p,portp=%p)\n", brdp,
2614 panelp, portp);
2615
2616 if ((brdp == NULL) || (panelp == NULL) ||
2617 (portp == NULL))
2618 return;
2619
2620 spin_lock_irqsave(&brd_lock, flags);
2621 portp->ioaddr = panelp->iobase + (((brdp->brdtype == BRD_ECHPCI) ||
2622 (portp->portnr < 8)) ? 0 : EREG_BANKSIZE);
2623 portp->uartaddr = (portp->portnr & 0x04) << 5;
2624 portp->pagenr = panelp->pagenr + (portp->portnr >> 3);
2625
2626 BRDENABLE(portp->brdnr, portp->pagenr);
2627 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
2628 stl_cd1400setreg(portp, LIVR, (portp->portnr << 3));
2629 portp->hwid = stl_cd1400getreg(portp, GFRCR);
2630 BRDDISABLE(portp->brdnr);
2631 spin_unlock_irqrestore(&brd_lock, flags);
2632}
2633
2634
2635
2636
2637
2638
2639
2640
2641static void stl_cd1400ccrwait(struct stlport *portp)
2642{
2643 int i;
2644
2645 for (i = 0; i < CCR_MAXWAIT; i++)
2646 if (stl_cd1400getreg(portp, CCR) == 0)
2647 return;
2648
2649 printk("STALLION: cd1400 not responding, port=%d panel=%d brd=%d\n",
2650 portp->portnr, portp->panelnr, portp->brdnr);
2651}
2652
2653
2654
2655
2656
2657
2658
2659
2660static void stl_cd1400setport(struct stlport *portp, struct ktermios *tiosp)
2661{
2662 struct stlbrd *brdp;
2663 unsigned long flags;
2664 unsigned int clkdiv, baudrate;
2665 unsigned char cor1, cor2, cor3;
2666 unsigned char cor4, cor5, ccr;
2667 unsigned char srer, sreron, sreroff;
2668 unsigned char mcor1, mcor2, rtpr;
2669 unsigned char clk, div;
2670
2671 cor1 = 0;
2672 cor2 = 0;
2673 cor3 = 0;
2674 cor4 = 0;
2675 cor5 = 0;
2676 ccr = 0;
2677 rtpr = 0;
2678 clk = 0;
2679 div = 0;
2680 mcor1 = 0;
2681 mcor2 = 0;
2682 sreron = 0;
2683 sreroff = 0;
2684
2685 brdp = stl_brds[portp->brdnr];
2686 if (brdp == NULL)
2687 return;
2688
2689
2690
2691
2692
2693
2694 portp->rxignoremsk = 0;
2695 if (tiosp->c_iflag & IGNPAR) {
2696 portp->rxignoremsk |= (ST_PARITY | ST_FRAMING | ST_OVERRUN);
2697 cor1 |= COR1_PARIGNORE;
2698 }
2699 if (tiosp->c_iflag & IGNBRK) {
2700 portp->rxignoremsk |= ST_BREAK;
2701 cor4 |= COR4_IGNBRK;
2702 }
2703
2704 portp->rxmarkmsk = ST_OVERRUN;
2705 if (tiosp->c_iflag & (INPCK | PARMRK))
2706 portp->rxmarkmsk |= (ST_PARITY | ST_FRAMING);
2707 if (tiosp->c_iflag & BRKINT)
2708 portp->rxmarkmsk |= ST_BREAK;
2709
2710
2711
2712
2713
2714 switch (tiosp->c_cflag & CSIZE) {
2715 case CS5:
2716 cor1 |= COR1_CHL5;
2717 break;
2718 case CS6:
2719 cor1 |= COR1_CHL6;
2720 break;
2721 case CS7:
2722 cor1 |= COR1_CHL7;
2723 break;
2724 default:
2725 cor1 |= COR1_CHL8;
2726 break;
2727 }
2728
2729 if (tiosp->c_cflag & CSTOPB)
2730 cor1 |= COR1_STOP2;
2731 else
2732 cor1 |= COR1_STOP1;
2733
2734 if (tiosp->c_cflag & PARENB) {
2735 if (tiosp->c_cflag & PARODD)
2736 cor1 |= (COR1_PARENB | COR1_PARODD);
2737 else
2738 cor1 |= (COR1_PARENB | COR1_PAREVEN);
2739 } else {
2740 cor1 |= COR1_PARNONE;
2741 }
2742
2743
2744
2745
2746
2747
2748
2749 cor3 |= FIFO_RXTHRESHOLD;
2750 rtpr = 2;
2751
2752
2753
2754
2755
2756
2757
2758 baudrate = tiosp->c_cflag & CBAUD;
2759 if (baudrate & CBAUDEX) {
2760 baudrate &= ~CBAUDEX;
2761 if ((baudrate < 1) || (baudrate > 4))
2762 tiosp->c_cflag &= ~CBAUDEX;
2763 else
2764 baudrate += 15;
2765 }
2766 baudrate = stl_baudrates[baudrate];
2767 if ((tiosp->c_cflag & CBAUD) == B38400) {
2768 if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
2769 baudrate = 57600;
2770 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
2771 baudrate = 115200;
2772 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
2773 baudrate = 230400;
2774 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
2775 baudrate = 460800;
2776 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)
2777 baudrate = (portp->baud_base / portp->custom_divisor);
2778 }
2779 if (baudrate > STL_CD1400MAXBAUD)
2780 baudrate = STL_CD1400MAXBAUD;
2781
2782 if (baudrate > 0) {
2783 for (clk = 0; clk < CD1400_NUMCLKS; clk++) {
2784 clkdiv = (portp->clk / stl_cd1400clkdivs[clk]) / baudrate;
2785 if (clkdiv < 0x100)
2786 break;
2787 }
2788 div = (unsigned char) clkdiv;
2789 }
2790
2791
2792
2793
2794 if ((tiosp->c_cflag & CLOCAL) == 0) {
2795 mcor1 |= MCOR1_DCD;
2796 mcor2 |= MCOR2_DCD;
2797 sreron |= SRER_MODEM;
2798 portp->port.flags |= ASYNC_CHECK_CD;
2799 } else
2800 portp->port.flags &= ~ASYNC_CHECK_CD;
2801
2802
2803
2804
2805
2806
2807
2808 if (tiosp->c_iflag & IXON) {
2809 cor2 |= COR2_TXIBE;
2810 cor3 |= COR3_SCD12;
2811 if (tiosp->c_iflag & IXANY)
2812 cor2 |= COR2_IXM;
2813 }
2814
2815 if (tiosp->c_cflag & CRTSCTS) {
2816 cor2 |= COR2_CTSAE;
2817 mcor1 |= FIFO_RTSTHRESHOLD;
2818 }
2819
2820
2821
2822
2823
2824
2825 pr_debug("SETPORT: portnr=%d panelnr=%d brdnr=%d\n",
2826 portp->portnr, portp->panelnr, portp->brdnr);
2827 pr_debug(" cor1=%x cor2=%x cor3=%x cor4=%x cor5=%x\n",
2828 cor1, cor2, cor3, cor4, cor5);
2829 pr_debug(" mcor1=%x mcor2=%x rtpr=%x sreron=%x sreroff=%x\n",
2830 mcor1, mcor2, rtpr, sreron, sreroff);
2831 pr_debug(" tcor=%x tbpr=%x rcor=%x rbpr=%x\n", clk, div, clk, div);
2832 pr_debug(" schr1=%x schr2=%x schr3=%x schr4=%x\n",
2833 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP],
2834 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP]);
2835
2836 spin_lock_irqsave(&brd_lock, flags);
2837 BRDENABLE(portp->brdnr, portp->pagenr);
2838 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x3));
2839 srer = stl_cd1400getreg(portp, SRER);
2840 stl_cd1400setreg(portp, SRER, 0);
2841 if (stl_cd1400updatereg(portp, COR1, cor1))
2842 ccr = 1;
2843 if (stl_cd1400updatereg(portp, COR2, cor2))
2844 ccr = 1;
2845 if (stl_cd1400updatereg(portp, COR3, cor3))
2846 ccr = 1;
2847 if (ccr) {
2848 stl_cd1400ccrwait(portp);
2849 stl_cd1400setreg(portp, CCR, CCR_CORCHANGE);
2850 }
2851 stl_cd1400setreg(portp, COR4, cor4);
2852 stl_cd1400setreg(portp, COR5, cor5);
2853 stl_cd1400setreg(portp, MCOR1, mcor1);
2854 stl_cd1400setreg(portp, MCOR2, mcor2);
2855 if (baudrate > 0) {
2856 stl_cd1400setreg(portp, TCOR, clk);
2857 stl_cd1400setreg(portp, TBPR, div);
2858 stl_cd1400setreg(portp, RCOR, clk);
2859 stl_cd1400setreg(portp, RBPR, div);
2860 }
2861 stl_cd1400setreg(portp, SCHR1, tiosp->c_cc[VSTART]);
2862 stl_cd1400setreg(portp, SCHR2, tiosp->c_cc[VSTOP]);
2863 stl_cd1400setreg(portp, SCHR3, tiosp->c_cc[VSTART]);
2864 stl_cd1400setreg(portp, SCHR4, tiosp->c_cc[VSTOP]);
2865 stl_cd1400setreg(portp, RTPR, rtpr);
2866 mcor1 = stl_cd1400getreg(portp, MSVR1);
2867 if (mcor1 & MSVR1_DCD)
2868 portp->sigs |= TIOCM_CD;
2869 else
2870 portp->sigs &= ~TIOCM_CD;
2871 stl_cd1400setreg(portp, SRER, ((srer & ~sreroff) | sreron));
2872 BRDDISABLE(portp->brdnr);
2873 spin_unlock_irqrestore(&brd_lock, flags);
2874}
2875
2876
2877
2878
2879
2880
2881
2882static void stl_cd1400setsignals(struct stlport *portp, int dtr, int rts)
2883{
2884 unsigned char msvr1, msvr2;
2885 unsigned long flags;
2886
2887 pr_debug("stl_cd1400setsignals(portp=%p,dtr=%d,rts=%d)\n",
2888 portp, dtr, rts);
2889
2890 msvr1 = 0;
2891 msvr2 = 0;
2892 if (dtr > 0)
2893 msvr1 = MSVR1_DTR;
2894 if (rts > 0)
2895 msvr2 = MSVR2_RTS;
2896
2897 spin_lock_irqsave(&brd_lock, flags);
2898 BRDENABLE(portp->brdnr, portp->pagenr);
2899 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
2900 if (rts >= 0)
2901 stl_cd1400setreg(portp, MSVR2, msvr2);
2902 if (dtr >= 0)
2903 stl_cd1400setreg(portp, MSVR1, msvr1);
2904 BRDDISABLE(portp->brdnr);
2905 spin_unlock_irqrestore(&brd_lock, flags);
2906}
2907
2908
2909
2910
2911
2912
2913
2914static int stl_cd1400getsignals(struct stlport *portp)
2915{
2916 unsigned char msvr1, msvr2;
2917 unsigned long flags;
2918 int sigs;
2919
2920 pr_debug("stl_cd1400getsignals(portp=%p)\n", portp);
2921
2922 spin_lock_irqsave(&brd_lock, flags);
2923 BRDENABLE(portp->brdnr, portp->pagenr);
2924 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
2925 msvr1 = stl_cd1400getreg(portp, MSVR1);
2926 msvr2 = stl_cd1400getreg(portp, MSVR2);
2927 BRDDISABLE(portp->brdnr);
2928 spin_unlock_irqrestore(&brd_lock, flags);
2929
2930 sigs = 0;
2931 sigs |= (msvr1 & MSVR1_DCD) ? TIOCM_CD : 0;
2932 sigs |= (msvr1 & MSVR1_CTS) ? TIOCM_CTS : 0;
2933 sigs |= (msvr1 & MSVR1_DTR) ? TIOCM_DTR : 0;
2934 sigs |= (msvr2 & MSVR2_RTS) ? TIOCM_RTS : 0;
2935#if 0
2936 sigs |= (msvr1 & MSVR1_RI) ? TIOCM_RI : 0;
2937 sigs |= (msvr1 & MSVR1_DSR) ? TIOCM_DSR : 0;
2938#else
2939 sigs |= TIOCM_DSR;
2940#endif
2941 return sigs;
2942}
2943
2944
2945
2946
2947
2948
2949
2950static void stl_cd1400enablerxtx(struct stlport *portp, int rx, int tx)
2951{
2952 unsigned char ccr;
2953 unsigned long flags;
2954
2955 pr_debug("stl_cd1400enablerxtx(portp=%p,rx=%d,tx=%d)\n", portp, rx, tx);
2956
2957 ccr = 0;
2958
2959 if (tx == 0)
2960 ccr |= CCR_TXDISABLE;
2961 else if (tx > 0)
2962 ccr |= CCR_TXENABLE;
2963 if (rx == 0)
2964 ccr |= CCR_RXDISABLE;
2965 else if (rx > 0)
2966 ccr |= CCR_RXENABLE;
2967
2968 spin_lock_irqsave(&brd_lock, flags);
2969 BRDENABLE(portp->brdnr, portp->pagenr);
2970 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
2971 stl_cd1400ccrwait(portp);
2972 stl_cd1400setreg(portp, CCR, ccr);
2973 stl_cd1400ccrwait(portp);
2974 BRDDISABLE(portp->brdnr);
2975 spin_unlock_irqrestore(&brd_lock, flags);
2976}
2977
2978
2979
2980
2981
2982
2983
2984static void stl_cd1400startrxtx(struct stlport *portp, int rx, int tx)
2985{
2986 unsigned char sreron, sreroff;
2987 unsigned long flags;
2988
2989 pr_debug("stl_cd1400startrxtx(portp=%p,rx=%d,tx=%d)\n", portp, rx, tx);
2990
2991 sreron = 0;
2992 sreroff = 0;
2993 if (tx == 0)
2994 sreroff |= (SRER_TXDATA | SRER_TXEMPTY);
2995 else if (tx == 1)
2996 sreron |= SRER_TXDATA;
2997 else if (tx >= 2)
2998 sreron |= SRER_TXEMPTY;
2999 if (rx == 0)
3000 sreroff |= SRER_RXDATA;
3001 else if (rx > 0)
3002 sreron |= SRER_RXDATA;
3003
3004 spin_lock_irqsave(&brd_lock, flags);
3005 BRDENABLE(portp->brdnr, portp->pagenr);
3006 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3007 stl_cd1400setreg(portp, SRER,
3008 ((stl_cd1400getreg(portp, SRER) & ~sreroff) | sreron));
3009 BRDDISABLE(portp->brdnr);
3010 if (tx > 0)
3011 set_bit(ASYI_TXBUSY, &portp->istate);
3012 spin_unlock_irqrestore(&brd_lock, flags);
3013}
3014
3015
3016
3017
3018
3019
3020
3021static void stl_cd1400disableintrs(struct stlport *portp)
3022{
3023 unsigned long flags;
3024
3025 pr_debug("stl_cd1400disableintrs(portp=%p)\n", portp);
3026
3027 spin_lock_irqsave(&brd_lock, flags);
3028 BRDENABLE(portp->brdnr, portp->pagenr);
3029 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3030 stl_cd1400setreg(portp, SRER, 0);
3031 BRDDISABLE(portp->brdnr);
3032 spin_unlock_irqrestore(&brd_lock, flags);
3033}
3034
3035
3036
3037static void stl_cd1400sendbreak(struct stlport *portp, int len)
3038{
3039 unsigned long flags;
3040
3041 pr_debug("stl_cd1400sendbreak(portp=%p,len=%d)\n", portp, len);
3042
3043 spin_lock_irqsave(&brd_lock, flags);
3044 BRDENABLE(portp->brdnr, portp->pagenr);
3045 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3046 stl_cd1400setreg(portp, SRER,
3047 ((stl_cd1400getreg(portp, SRER) & ~SRER_TXDATA) |
3048 SRER_TXEMPTY));
3049 BRDDISABLE(portp->brdnr);
3050 portp->brklen = len;
3051 if (len == 1)
3052 portp->stats.txbreaks++;
3053 spin_unlock_irqrestore(&brd_lock, flags);
3054}
3055
3056
3057
3058
3059
3060
3061
3062static void stl_cd1400flowctrl(struct stlport *portp, int state)
3063{
3064 struct tty_struct *tty;
3065 unsigned long flags;
3066
3067 pr_debug("stl_cd1400flowctrl(portp=%p,state=%x)\n", portp, state);
3068
3069 if (portp == NULL)
3070 return;
3071 tty = tty_port_tty_get(&portp->port);
3072 if (tty == NULL)
3073 return;
3074
3075 spin_lock_irqsave(&brd_lock, flags);
3076 BRDENABLE(portp->brdnr, portp->pagenr);
3077 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3078
3079 if (state) {
3080 if (tty->termios->c_iflag & IXOFF) {
3081 stl_cd1400ccrwait(portp);
3082 stl_cd1400setreg(portp, CCR, CCR_SENDSCHR1);
3083 portp->stats.rxxon++;
3084 stl_cd1400ccrwait(portp);
3085 }
3086
3087
3088
3089
3090
3091
3092 if (tty->termios->c_cflag & CRTSCTS) {
3093 stl_cd1400setreg(portp, MCOR1,
3094 (stl_cd1400getreg(portp, MCOR1) |
3095 FIFO_RTSTHRESHOLD));
3096 stl_cd1400setreg(portp, MSVR2, MSVR2_RTS);
3097 portp->stats.rxrtson++;
3098 }
3099 } else {
3100 if (tty->termios->c_iflag & IXOFF) {
3101 stl_cd1400ccrwait(portp);
3102 stl_cd1400setreg(portp, CCR, CCR_SENDSCHR2);
3103 portp->stats.rxxoff++;
3104 stl_cd1400ccrwait(portp);
3105 }
3106 if (tty->termios->c_cflag & CRTSCTS) {
3107 stl_cd1400setreg(portp, MCOR1,
3108 (stl_cd1400getreg(portp, MCOR1) & 0xf0));
3109 stl_cd1400setreg(portp, MSVR2, 0);
3110 portp->stats.rxrtsoff++;
3111 }
3112 }
3113
3114 BRDDISABLE(portp->brdnr);
3115 spin_unlock_irqrestore(&brd_lock, flags);
3116 tty_kref_put(tty);
3117}
3118
3119
3120
3121
3122
3123
3124
3125static void stl_cd1400sendflow(struct stlport *portp, int state)
3126{
3127 struct tty_struct *tty;
3128 unsigned long flags;
3129
3130 pr_debug("stl_cd1400sendflow(portp=%p,state=%x)\n", portp, state);
3131
3132 if (portp == NULL)
3133 return;
3134 tty = tty_port_tty_get(&portp->port);
3135 if (tty == NULL)
3136 return;
3137
3138 spin_lock_irqsave(&brd_lock, flags);
3139 BRDENABLE(portp->brdnr, portp->pagenr);
3140 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3141 if (state) {
3142 stl_cd1400ccrwait(portp);
3143 stl_cd1400setreg(portp, CCR, CCR_SENDSCHR1);
3144 portp->stats.rxxon++;
3145 stl_cd1400ccrwait(portp);
3146 } else {
3147 stl_cd1400ccrwait(portp);
3148 stl_cd1400setreg(portp, CCR, CCR_SENDSCHR2);
3149 portp->stats.rxxoff++;
3150 stl_cd1400ccrwait(portp);
3151 }
3152 BRDDISABLE(portp->brdnr);
3153 spin_unlock_irqrestore(&brd_lock, flags);
3154 tty_kref_put(tty);
3155}
3156
3157
3158
3159static void stl_cd1400flush(struct stlport *portp)
3160{
3161 unsigned long flags;
3162
3163 pr_debug("stl_cd1400flush(portp=%p)\n", portp);
3164
3165 if (portp == NULL)
3166 return;
3167
3168 spin_lock_irqsave(&brd_lock, flags);
3169 BRDENABLE(portp->brdnr, portp->pagenr);
3170 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3171 stl_cd1400ccrwait(portp);
3172 stl_cd1400setreg(portp, CCR, CCR_TXFLUSHFIFO);
3173 stl_cd1400ccrwait(portp);
3174 portp->tx.tail = portp->tx.head;
3175 BRDDISABLE(portp->brdnr);
3176 spin_unlock_irqrestore(&brd_lock, flags);
3177}
3178
3179
3180
3181
3182
3183
3184
3185
3186
3187
3188static int stl_cd1400datastate(struct stlport *portp)
3189{
3190 pr_debug("stl_cd1400datastate(portp=%p)\n", portp);
3191
3192 if (portp == NULL)
3193 return 0;
3194
3195 return test_bit(ASYI_TXBUSY, &portp->istate) ? 1 : 0;
3196}
3197
3198
3199
3200
3201
3202
3203
3204static void stl_cd1400eiointr(struct stlpanel *panelp, unsigned int iobase)
3205{
3206 unsigned char svrtype;
3207
3208 pr_debug("stl_cd1400eiointr(panelp=%p,iobase=%x)\n", panelp, iobase);
3209
3210 spin_lock(&brd_lock);
3211 outb(SVRR, iobase);
3212 svrtype = inb(iobase + EREG_DATA);
3213 if (panelp->nrports > 4) {
3214 outb((SVRR + 0x80), iobase);
3215 svrtype |= inb(iobase + EREG_DATA);
3216 }
3217
3218 if (svrtype & SVRR_RX)
3219 stl_cd1400rxisr(panelp, iobase);
3220 else if (svrtype & SVRR_TX)
3221 stl_cd1400txisr(panelp, iobase);
3222 else if (svrtype & SVRR_MDM)
3223 stl_cd1400mdmisr(panelp, iobase);
3224
3225 spin_unlock(&brd_lock);
3226}
3227
3228
3229
3230
3231
3232
3233
3234static void stl_cd1400echintr(struct stlpanel *panelp, unsigned int iobase)
3235{
3236 unsigned char svrtype;
3237
3238 pr_debug("stl_cd1400echintr(panelp=%p,iobase=%x)\n", panelp, iobase);
3239
3240 outb(SVRR, iobase);
3241 svrtype = inb(iobase + EREG_DATA);
3242 outb((SVRR + 0x80), iobase);
3243 svrtype |= inb(iobase + EREG_DATA);
3244 if (svrtype & SVRR_RX)
3245 stl_cd1400rxisr(panelp, iobase);
3246 else if (svrtype & SVRR_TX)
3247 stl_cd1400txisr(panelp, iobase);
3248 else if (svrtype & SVRR_MDM)
3249 stl_cd1400mdmisr(panelp, iobase);
3250}
3251
3252
3253
3254
3255
3256
3257
3258
3259
3260static int stl_cd1400breakisr(struct stlport *portp, int ioaddr)
3261{
3262 if (portp->brklen == 1) {
3263 outb((COR2 + portp->uartaddr), ioaddr);
3264 outb((inb(ioaddr + EREG_DATA) | COR2_ETC),
3265 (ioaddr + EREG_DATA));
3266 outb((TDR + portp->uartaddr), ioaddr);
3267 outb(ETC_CMD, (ioaddr + EREG_DATA));
3268 outb(ETC_STARTBREAK, (ioaddr + EREG_DATA));
3269 outb((SRER + portp->uartaddr), ioaddr);
3270 outb((inb(ioaddr + EREG_DATA) & ~(SRER_TXDATA | SRER_TXEMPTY)),
3271 (ioaddr + EREG_DATA));
3272 return 1;
3273 } else if (portp->brklen > 1) {
3274 outb((TDR + portp->uartaddr), ioaddr);
3275 outb(ETC_CMD, (ioaddr + EREG_DATA));
3276 outb(ETC_STOPBREAK, (ioaddr + EREG_DATA));
3277 portp->brklen = -1;
3278 return 1;
3279 } else {
3280 outb((COR2 + portp->uartaddr), ioaddr);
3281 outb((inb(ioaddr + EREG_DATA) & ~COR2_ETC),
3282 (ioaddr + EREG_DATA));
3283 portp->brklen = 0;
3284 }
3285 return 0;
3286}
3287
3288
3289
3290
3291
3292
3293
3294
3295
3296
3297
3298
3299
3300
3301
3302static void stl_cd1400txisr(struct stlpanel *panelp, int ioaddr)
3303{
3304 struct stlport *portp;
3305 int len, stlen;
3306 char *head, *tail;
3307 unsigned char ioack, srer;
3308 struct tty_struct *tty;
3309
3310 pr_debug("stl_cd1400txisr(panelp=%p,ioaddr=%x)\n", panelp, ioaddr);
3311
3312 ioack = inb(ioaddr + EREG_TXACK);
3313 if (((ioack & panelp->ackmask) != 0) ||
3314 ((ioack & ACK_TYPMASK) != ACK_TYPTX)) {
3315 printk("STALLION: bad TX interrupt ack value=%x\n", ioack);
3316 return;
3317 }
3318 portp = panelp->ports[(ioack >> 3)];
3319
3320
3321
3322
3323
3324
3325 if (portp->brklen != 0)
3326 if (stl_cd1400breakisr(portp, ioaddr))
3327 goto stl_txalldone;
3328
3329 head = portp->tx.head;
3330 tail = portp->tx.tail;
3331 len = (head >= tail) ? (head - tail) : (STL_TXBUFSIZE - (tail - head));
3332 if ((len == 0) || ((len < STL_TXBUFLOW) &&
3333 (test_bit(ASYI_TXLOW, &portp->istate) == 0))) {
3334 set_bit(ASYI_TXLOW, &portp->istate);
3335 tty = tty_port_tty_get(&portp->port);
3336 if (tty) {
3337 tty_wakeup(tty);
3338 tty_kref_put(tty);
3339 }
3340 }
3341
3342 if (len == 0) {
3343 outb((SRER + portp->uartaddr), ioaddr);
3344 srer = inb(ioaddr + EREG_DATA);
3345 if (srer & SRER_TXDATA) {
3346 srer = (srer & ~SRER_TXDATA) | SRER_TXEMPTY;
3347 } else {
3348 srer &= ~(SRER_TXDATA | SRER_TXEMPTY);
3349 clear_bit(ASYI_TXBUSY, &portp->istate);
3350 }
3351 outb(srer, (ioaddr + EREG_DATA));
3352 } else {
3353 len = min(len, CD1400_TXFIFOSIZE);
3354 portp->stats.txtotal += len;
3355 stlen = min_t(unsigned int, len,
3356 (portp->tx.buf + STL_TXBUFSIZE) - tail);
3357 outb((TDR + portp->uartaddr), ioaddr);
3358 outsb((ioaddr + EREG_DATA), tail, stlen);
3359 len -= stlen;
3360 tail += stlen;
3361 if (tail >= (portp->tx.buf + STL_TXBUFSIZE))
3362 tail = portp->tx.buf;
3363 if (len > 0) {
3364 outsb((ioaddr + EREG_DATA), tail, len);
3365 tail += len;
3366 }
3367 portp->tx.tail = tail;
3368 }
3369
3370stl_txalldone:
3371 outb((EOSRR + portp->uartaddr), ioaddr);
3372 outb(0, (ioaddr + EREG_DATA));
3373}
3374
3375
3376
3377
3378
3379
3380
3381
3382
3383
3384
3385
3386
3387static void stl_cd1400rxisr(struct stlpanel *panelp, int ioaddr)
3388{
3389 struct stlport *portp;
3390 struct tty_struct *tty;
3391 unsigned int ioack, len, buflen;
3392 unsigned char status;
3393 char ch;
3394
3395 pr_debug("stl_cd1400rxisr(panelp=%p,ioaddr=%x)\n", panelp, ioaddr);
3396
3397 ioack = inb(ioaddr + EREG_RXACK);
3398 if ((ioack & panelp->ackmask) != 0) {
3399 printk("STALLION: bad RX interrupt ack value=%x\n", ioack);
3400 return;
3401 }
3402 portp = panelp->ports[(ioack >> 3)];
3403 tty = tty_port_tty_get(&portp->port);
3404
3405 if ((ioack & ACK_TYPMASK) == ACK_TYPRXGOOD) {
3406 outb((RDCR + portp->uartaddr), ioaddr);
3407 len = inb(ioaddr + EREG_DATA);
3408 if (tty == NULL || (buflen = tty_buffer_request_room(tty, len)) == 0) {
3409 len = min_t(unsigned int, len, sizeof(stl_unwanted));
3410 outb((RDSR + portp->uartaddr), ioaddr);
3411 insb((ioaddr + EREG_DATA), &stl_unwanted[0], len);
3412 portp->stats.rxlost += len;
3413 portp->stats.rxtotal += len;
3414 } else {
3415 len = min(len, buflen);
3416 if (len > 0) {
3417 unsigned char *ptr;
3418 outb((RDSR + portp->uartaddr), ioaddr);
3419 tty_prepare_flip_string(tty, &ptr, len);
3420 insb((ioaddr + EREG_DATA), ptr, len);
3421 tty_schedule_flip(tty);
3422 portp->stats.rxtotal += len;
3423 }
3424 }
3425 } else if ((ioack & ACK_TYPMASK) == ACK_TYPRXBAD) {
3426 outb((RDSR + portp->uartaddr), ioaddr);
3427 status = inb(ioaddr + EREG_DATA);
3428 ch = inb(ioaddr + EREG_DATA);
3429 if (status & ST_PARITY)
3430 portp->stats.rxparity++;
3431 if (status & ST_FRAMING)
3432 portp->stats.rxframing++;
3433 if (status & ST_OVERRUN)
3434 portp->stats.rxoverrun++;
3435 if (status & ST_BREAK)
3436 portp->stats.rxbreaks++;
3437 if (status & ST_SCHARMASK) {
3438 if ((status & ST_SCHARMASK) == ST_SCHAR1)
3439 portp->stats.txxon++;
3440 if ((status & ST_SCHARMASK) == ST_SCHAR2)
3441 portp->stats.txxoff++;
3442 goto stl_rxalldone;
3443 }
3444 if (tty != NULL && (portp->rxignoremsk & status) == 0) {
3445 if (portp->rxmarkmsk & status) {
3446 if (status & ST_BREAK) {
3447 status = TTY_BREAK;
3448 if (portp->port.flags & ASYNC_SAK) {
3449 do_SAK(tty);
3450 BRDENABLE(portp->brdnr, portp->pagenr);
3451 }
3452 } else if (status & ST_PARITY)
3453 status = TTY_PARITY;
3454 else if (status & ST_FRAMING)
3455 status = TTY_FRAME;
3456 else if(status & ST_OVERRUN)
3457 status = TTY_OVERRUN;
3458 else
3459 status = 0;
3460 } else
3461 status = 0;
3462 tty_insert_flip_char(tty, ch, status);
3463 tty_schedule_flip(tty);
3464 }
3465 } else {
3466 printk("STALLION: bad RX interrupt ack value=%x\n", ioack);
3467 tty_kref_put(tty);
3468 return;
3469 }
3470
3471stl_rxalldone:
3472 tty_kref_put(tty);
3473 outb((EOSRR + portp->uartaddr), ioaddr);
3474 outb(0, (ioaddr + EREG_DATA));
3475}
3476
3477
3478
3479
3480
3481
3482
3483
3484
3485static void stl_cd1400mdmisr(struct stlpanel *panelp, int ioaddr)
3486{
3487 struct stlport *portp;
3488 unsigned int ioack;
3489 unsigned char misr;
3490
3491 pr_debug("stl_cd1400mdmisr(panelp=%p)\n", panelp);
3492
3493 ioack = inb(ioaddr + EREG_MDACK);
3494 if (((ioack & panelp->ackmask) != 0) ||
3495 ((ioack & ACK_TYPMASK) != ACK_TYPMDM)) {
3496 printk("STALLION: bad MODEM interrupt ack value=%x\n", ioack);
3497 return;
3498 }
3499 portp = panelp->ports[(ioack >> 3)];
3500
3501 outb((MISR + portp->uartaddr), ioaddr);
3502 misr = inb(ioaddr + EREG_DATA);
3503 if (misr & MISR_DCD) {
3504 stl_cd_change(portp);
3505 portp->stats.modem++;
3506 }
3507
3508 outb((EOSRR + portp->uartaddr), ioaddr);
3509 outb(0, (ioaddr + EREG_DATA));
3510}
3511
3512
3513
3514
3515
3516
3517
3518
3519
3520
3521
3522static int stl_sc26198getreg(struct stlport *portp, int regnr)
3523{
3524 outb((regnr | portp->uartaddr), (portp->ioaddr + XP_ADDR));
3525 return inb(portp->ioaddr + XP_DATA);
3526}
3527
3528static void stl_sc26198setreg(struct stlport *portp, int regnr, int value)
3529{
3530 outb((regnr | portp->uartaddr), (portp->ioaddr + XP_ADDR));
3531 outb(value, (portp->ioaddr + XP_DATA));
3532}
3533
3534static int stl_sc26198updatereg(struct stlport *portp, int regnr, int value)
3535{
3536 outb((regnr | portp->uartaddr), (portp->ioaddr + XP_ADDR));
3537 if (inb(portp->ioaddr + XP_DATA) != value) {
3538 outb(value, (portp->ioaddr + XP_DATA));
3539 return 1;
3540 }
3541 return 0;
3542}
3543
3544
3545
3546
3547
3548
3549
3550static int stl_sc26198getglobreg(struct stlport *portp, int regnr)
3551{
3552 outb(regnr, (portp->ioaddr + XP_ADDR));
3553 return inb(portp->ioaddr + XP_DATA);
3554}
3555
3556#if 0
3557static void stl_sc26198setglobreg(struct stlport *portp, int regnr, int value)
3558{
3559 outb(regnr, (portp->ioaddr + XP_ADDR));
3560 outb(value, (portp->ioaddr + XP_DATA));
3561}
3562#endif
3563
3564
3565
3566
3567
3568
3569
3570
3571
3572static int stl_sc26198panelinit(struct stlbrd *brdp, struct stlpanel *panelp)
3573{
3574 int chipmask, i;
3575 int nrchips, ioaddr;
3576
3577 pr_debug("stl_sc26198panelinit(brdp=%p,panelp=%p)\n", brdp, panelp);
3578
3579 BRDENABLE(panelp->brdnr, panelp->pagenr);
3580
3581
3582
3583
3584 chipmask = 0;
3585 nrchips = (panelp->nrports + 4) / SC26198_PORTS;
3586 if (brdp->brdtype == BRD_ECHPCI)
3587 outb(panelp->pagenr, brdp->ioctrl);
3588
3589 for (i = 0; i < nrchips; i++) {
3590 ioaddr = panelp->iobase + (i * 4);
3591 outb(SCCR, (ioaddr + XP_ADDR));
3592 outb(CR_RESETALL, (ioaddr + XP_DATA));
3593 outb(TSTR, (ioaddr + XP_ADDR));
3594 if (inb(ioaddr + XP_DATA) != 0) {
3595 printk("STALLION: sc26198 not responding, "
3596 "brd=%d panel=%d chip=%d\n",
3597 panelp->brdnr, panelp->panelnr, i);
3598 continue;
3599 }
3600 chipmask |= (0x1 << i);
3601 outb(GCCR, (ioaddr + XP_ADDR));
3602 outb(GCCR_IVRTYPCHANACK, (ioaddr + XP_DATA));
3603 outb(WDTRCR, (ioaddr + XP_ADDR));
3604 outb(0xff, (ioaddr + XP_DATA));
3605 }
3606
3607 BRDDISABLE(panelp->brdnr);
3608 return chipmask;
3609}
3610
3611
3612
3613
3614
3615
3616
3617static void stl_sc26198portinit(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp)
3618{
3619 pr_debug("stl_sc26198portinit(brdp=%p,panelp=%p,portp=%p)\n", brdp,
3620 panelp, portp);
3621
3622 if ((brdp == NULL) || (panelp == NULL) ||
3623 (portp == NULL))
3624 return;
3625
3626 portp->ioaddr = panelp->iobase + ((portp->portnr < 8) ? 0 : 4);
3627 portp->uartaddr = (portp->portnr & 0x07) << 4;
3628 portp->pagenr = panelp->pagenr;
3629 portp->hwid = 0x1;
3630
3631 BRDENABLE(portp->brdnr, portp->pagenr);
3632 stl_sc26198setreg(portp, IOPCR, IOPCR_SETSIGS);
3633 BRDDISABLE(portp->brdnr);
3634}
3635
3636
3637
3638
3639
3640
3641
3642
3643static void stl_sc26198setport(struct stlport *portp, struct ktermios *tiosp)
3644{
3645 struct stlbrd *brdp;
3646 unsigned long flags;
3647 unsigned int baudrate;
3648 unsigned char mr0, mr1, mr2, clk;
3649 unsigned char imron, imroff, iopr, ipr;
3650
3651 mr0 = 0;
3652 mr1 = 0;
3653 mr2 = 0;
3654 clk = 0;
3655 iopr = 0;
3656 imron = 0;
3657 imroff = 0;
3658
3659 brdp = stl_brds[portp->brdnr];
3660 if (brdp == NULL)
3661 return;
3662
3663
3664
3665
3666
3667 portp->rxignoremsk = 0;
3668 if (tiosp->c_iflag & IGNPAR)
3669 portp->rxignoremsk |= (SR_RXPARITY | SR_RXFRAMING |
3670 SR_RXOVERRUN);
3671 if (tiosp->c_iflag & IGNBRK)
3672 portp->rxignoremsk |= SR_RXBREAK;
3673
3674 portp->rxmarkmsk = SR_RXOVERRUN;
3675 if (tiosp->c_iflag & (INPCK | PARMRK))
3676 portp->rxmarkmsk |= (SR_RXPARITY | SR_RXFRAMING);
3677 if (tiosp->c_iflag & BRKINT)
3678 portp->rxmarkmsk |= SR_RXBREAK;
3679
3680
3681
3682
3683
3684 switch (tiosp->c_cflag & CSIZE) {
3685 case CS5:
3686 mr1 |= MR1_CS5;
3687 break;
3688 case CS6:
3689 mr1 |= MR1_CS6;
3690 break;
3691 case CS7:
3692 mr1 |= MR1_CS7;
3693 break;
3694 default:
3695 mr1 |= MR1_CS8;
3696 break;
3697 }
3698
3699 if (tiosp->c_cflag & CSTOPB)
3700 mr2 |= MR2_STOP2;
3701 else
3702 mr2 |= MR2_STOP1;
3703
3704 if (tiosp->c_cflag & PARENB) {
3705 if (tiosp->c_cflag & PARODD)
3706 mr1 |= (MR1_PARENB | MR1_PARODD);
3707 else
3708 mr1 |= (MR1_PARENB | MR1_PAREVEN);
3709 } else
3710 mr1 |= MR1_PARNONE;
3711
3712 mr1 |= MR1_ERRBLOCK;
3713
3714
3715
3716
3717
3718
3719 mr2 |= MR2_RXFIFOHALF;
3720
3721
3722
3723
3724
3725
3726 baudrate = tiosp->c_cflag & CBAUD;
3727 if (baudrate & CBAUDEX) {
3728 baudrate &= ~CBAUDEX;
3729 if ((baudrate < 1) || (baudrate > 4))
3730 tiosp->c_cflag &= ~CBAUDEX;
3731 else
3732 baudrate += 15;
3733 }
3734 baudrate = stl_baudrates[baudrate];
3735 if ((tiosp->c_cflag & CBAUD) == B38400) {
3736 if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
3737 baudrate = 57600;
3738 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
3739 baudrate = 115200;
3740 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
3741 baudrate = 230400;
3742 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
3743 baudrate = 460800;
3744 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)
3745 baudrate = (portp->baud_base / portp->custom_divisor);
3746 }
3747 if (baudrate > STL_SC26198MAXBAUD)
3748 baudrate = STL_SC26198MAXBAUD;
3749
3750 if (baudrate > 0)
3751 for (clk = 0; clk < SC26198_NRBAUDS; clk++)
3752 if (baudrate <= sc26198_baudtable[clk])
3753 break;
3754
3755
3756
3757
3758 if (tiosp->c_cflag & CLOCAL) {
3759 portp->port.flags &= ~ASYNC_CHECK_CD;
3760 } else {
3761 iopr |= IOPR_DCDCOS;
3762 imron |= IR_IOPORT;
3763 portp->port.flags |= ASYNC_CHECK_CD;
3764 }
3765
3766
3767
3768
3769
3770
3771
3772 if (tiosp->c_iflag & IXON) {
3773 mr0 |= MR0_SWFTX | MR0_SWFT;
3774 imron |= IR_XONXOFF;
3775 } else
3776 imroff |= IR_XONXOFF;
3777
3778 if (tiosp->c_iflag & IXOFF)
3779 mr0 |= MR0_SWFRX;
3780
3781 if (tiosp->c_cflag & CRTSCTS) {
3782 mr2 |= MR2_AUTOCTS;
3783 mr1 |= MR1_AUTORTS;
3784 }
3785
3786
3787
3788
3789
3790
3791 pr_debug("SETPORT: portnr=%d panelnr=%d brdnr=%d\n",
3792 portp->portnr, portp->panelnr, portp->brdnr);
3793 pr_debug(" mr0=%x mr1=%x mr2=%x clk=%x\n", mr0, mr1, mr2, clk);
3794 pr_debug(" iopr=%x imron=%x imroff=%x\n", iopr, imron, imroff);
3795 pr_debug(" schr1=%x schr2=%x schr3=%x schr4=%x\n",
3796 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP],
3797 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP]);
3798
3799 spin_lock_irqsave(&brd_lock, flags);
3800 BRDENABLE(portp->brdnr, portp->pagenr);
3801 stl_sc26198setreg(portp, IMR, 0);
3802 stl_sc26198updatereg(portp, MR0, mr0);
3803 stl_sc26198updatereg(portp, MR1, mr1);
3804 stl_sc26198setreg(portp, SCCR, CR_RXERRBLOCK);
3805 stl_sc26198updatereg(portp, MR2, mr2);
3806 stl_sc26198updatereg(portp, IOPIOR,
3807 ((stl_sc26198getreg(portp, IOPIOR) & ~IPR_CHANGEMASK) | iopr));
3808
3809 if (baudrate > 0) {
3810 stl_sc26198setreg(portp, TXCSR, clk);
3811 stl_sc26198setreg(portp, RXCSR, clk);
3812 }
3813
3814 stl_sc26198setreg(portp, XONCR, tiosp->c_cc[VSTART]);
3815 stl_sc26198setreg(portp, XOFFCR, tiosp->c_cc[VSTOP]);
3816
3817 ipr = stl_sc26198getreg(portp, IPR);
3818 if (ipr & IPR_DCD)
3819 portp->sigs &= ~TIOCM_CD;
3820 else
3821 portp->sigs |= TIOCM_CD;
3822
3823 portp->imr = (portp->imr & ~imroff) | imron;
3824 stl_sc26198setreg(portp, IMR, portp->imr);
3825 BRDDISABLE(portp->brdnr);
3826 spin_unlock_irqrestore(&brd_lock, flags);
3827}
3828
3829
3830
3831
3832
3833
3834
3835static void stl_sc26198setsignals(struct stlport *portp, int dtr, int rts)
3836{
3837 unsigned char iopioron, iopioroff;
3838 unsigned long flags;
3839
3840 pr_debug("stl_sc26198setsignals(portp=%p,dtr=%d,rts=%d)\n", portp,
3841 dtr, rts);
3842
3843 iopioron = 0;
3844 iopioroff = 0;
3845 if (dtr == 0)
3846 iopioroff |= IPR_DTR;
3847 else if (dtr > 0)
3848 iopioron |= IPR_DTR;
3849 if (rts == 0)
3850 iopioroff |= IPR_RTS;
3851 else if (rts > 0)
3852 iopioron |= IPR_RTS;
3853
3854 spin_lock_irqsave(&brd_lock, flags);
3855 BRDENABLE(portp->brdnr, portp->pagenr);
3856 stl_sc26198setreg(portp, IOPIOR,
3857 ((stl_sc26198getreg(portp, IOPIOR) & ~iopioroff) | iopioron));
3858 BRDDISABLE(portp->brdnr);
3859 spin_unlock_irqrestore(&brd_lock, flags);
3860}
3861
3862
3863
3864
3865
3866
3867
3868static int stl_sc26198getsignals(struct stlport *portp)
3869{
3870 unsigned char ipr;
3871 unsigned long flags;
3872 int sigs;
3873
3874 pr_debug("stl_sc26198getsignals(portp=%p)\n", portp);
3875
3876 spin_lock_irqsave(&brd_lock, flags);
3877 BRDENABLE(portp->brdnr, portp->pagenr);
3878 ipr = stl_sc26198getreg(portp, IPR);
3879 BRDDISABLE(portp->brdnr);
3880 spin_unlock_irqrestore(&brd_lock, flags);
3881
3882 sigs = 0;
3883 sigs |= (ipr & IPR_DCD) ? 0 : TIOCM_CD;
3884 sigs |= (ipr & IPR_CTS) ? 0 : TIOCM_CTS;
3885 sigs |= (ipr & IPR_DTR) ? 0: TIOCM_DTR;
3886 sigs |= (ipr & IPR_RTS) ? 0: TIOCM_RTS;
3887 sigs |= TIOCM_DSR;
3888 return sigs;
3889}
3890
3891
3892
3893
3894
3895
3896
3897static void stl_sc26198enablerxtx(struct stlport *portp, int rx, int tx)
3898{
3899 unsigned char ccr;
3900 unsigned long flags;
3901
3902 pr_debug("stl_sc26198enablerxtx(portp=%p,rx=%d,tx=%d)\n", portp, rx,tx);
3903
3904 ccr = portp->crenable;
3905 if (tx == 0)
3906 ccr &= ~CR_TXENABLE;
3907 else if (tx > 0)
3908 ccr |= CR_TXENABLE;
3909 if (rx == 0)
3910 ccr &= ~CR_RXENABLE;
3911 else if (rx > 0)
3912 ccr |= CR_RXENABLE;
3913
3914 spin_lock_irqsave(&brd_lock, flags);
3915 BRDENABLE(portp->brdnr, portp->pagenr);
3916 stl_sc26198setreg(portp, SCCR, ccr);
3917 BRDDISABLE(portp->brdnr);
3918 portp->crenable = ccr;
3919 spin_unlock_irqrestore(&brd_lock, flags);
3920}
3921
3922
3923
3924
3925
3926
3927
3928static void stl_sc26198startrxtx(struct stlport *portp, int rx, int tx)
3929{
3930 unsigned char imr;
3931 unsigned long flags;
3932
3933 pr_debug("stl_sc26198startrxtx(portp=%p,rx=%d,tx=%d)\n", portp, rx, tx);
3934
3935 imr = portp->imr;
3936 if (tx == 0)
3937 imr &= ~IR_TXRDY;
3938 else if (tx == 1)
3939 imr |= IR_TXRDY;
3940 if (rx == 0)
3941 imr &= ~(IR_RXRDY | IR_RXBREAK | IR_RXWATCHDOG);
3942 else if (rx > 0)
3943 imr |= IR_RXRDY | IR_RXBREAK | IR_RXWATCHDOG;
3944
3945 spin_lock_irqsave(&brd_lock, flags);
3946 BRDENABLE(portp->brdnr, portp->pagenr);
3947 stl_sc26198setreg(portp, IMR, imr);
3948 BRDDISABLE(portp->brdnr);
3949 portp->imr = imr;
3950 if (tx > 0)
3951 set_bit(ASYI_TXBUSY, &portp->istate);
3952 spin_unlock_irqrestore(&brd_lock, flags);
3953}
3954
3955
3956
3957
3958
3959
3960
3961static void stl_sc26198disableintrs(struct stlport *portp)
3962{
3963 unsigned long flags;
3964
3965 pr_debug("stl_sc26198disableintrs(portp=%p)\n", portp);
3966
3967 spin_lock_irqsave(&brd_lock, flags);
3968 BRDENABLE(portp->brdnr, portp->pagenr);
3969 portp->imr = 0;
3970 stl_sc26198setreg(portp, IMR, 0);
3971 BRDDISABLE(portp->brdnr);
3972 spin_unlock_irqrestore(&brd_lock, flags);
3973}
3974
3975
3976
3977static void stl_sc26198sendbreak(struct stlport *portp, int len)
3978{
3979 unsigned long flags;
3980
3981 pr_debug("stl_sc26198sendbreak(portp=%p,len=%d)\n", portp, len);
3982
3983 spin_lock_irqsave(&brd_lock, flags);
3984 BRDENABLE(portp->brdnr, portp->pagenr);
3985 if (len == 1) {
3986 stl_sc26198setreg(portp, SCCR, CR_TXSTARTBREAK);
3987 portp->stats.txbreaks++;
3988 } else
3989 stl_sc26198setreg(portp, SCCR, CR_TXSTOPBREAK);
3990
3991 BRDDISABLE(portp->brdnr);
3992 spin_unlock_irqrestore(&brd_lock, flags);
3993}
3994
3995
3996
3997
3998
3999
4000
4001static void stl_sc26198flowctrl(struct stlport *portp, int state)
4002{
4003 struct tty_struct *tty;
4004 unsigned long flags;
4005 unsigned char mr0;
4006
4007 pr_debug("stl_sc26198flowctrl(portp=%p,state=%x)\n", portp, state);
4008
4009 if (portp == NULL)
4010 return;
4011 tty = tty_port_tty_get(&portp->port);
4012 if (tty == NULL)
4013 return;
4014
4015 spin_lock_irqsave(&brd_lock, flags);
4016 BRDENABLE(portp->brdnr, portp->pagenr);
4017
4018 if (state) {
4019 if (tty->termios->c_iflag & IXOFF) {
4020 mr0 = stl_sc26198getreg(portp, MR0);
4021 stl_sc26198setreg(portp, MR0, (mr0 & ~MR0_SWFRXTX));
4022 stl_sc26198setreg(portp, SCCR, CR_TXSENDXON);
4023 mr0 |= MR0_SWFRX;
4024 portp->stats.rxxon++;
4025 stl_sc26198wait(portp);
4026 stl_sc26198setreg(portp, MR0, mr0);
4027 }
4028
4029
4030
4031
4032
4033
4034 if (tty->termios->c_cflag & CRTSCTS) {
4035 stl_sc26198setreg(portp, MR1,
4036 (stl_sc26198getreg(portp, MR1) | MR1_AUTORTS));
4037 stl_sc26198setreg(portp, IOPIOR,
4038 (stl_sc26198getreg(portp, IOPIOR) | IOPR_RTS));
4039 portp->stats.rxrtson++;
4040 }
4041 } else {
4042 if (tty->termios->c_iflag & IXOFF) {
4043 mr0 = stl_sc26198getreg(portp, MR0);
4044 stl_sc26198setreg(portp, MR0, (mr0 & ~MR0_SWFRXTX));
4045 stl_sc26198setreg(portp, SCCR, CR_TXSENDXOFF);
4046 mr0 &= ~MR0_SWFRX;
4047 portp->stats.rxxoff++;
4048 stl_sc26198wait(portp);
4049 stl_sc26198setreg(portp, MR0, mr0);
4050 }
4051 if (tty->termios->c_cflag & CRTSCTS) {
4052 stl_sc26198setreg(portp, MR1,
4053 (stl_sc26198getreg(portp, MR1) & ~MR1_AUTORTS));
4054 stl_sc26198setreg(portp, IOPIOR,
4055 (stl_sc26198getreg(portp, IOPIOR) & ~IOPR_RTS));
4056 portp->stats.rxrtsoff++;
4057 }
4058 }
4059
4060 BRDDISABLE(portp->brdnr);
4061 spin_unlock_irqrestore(&brd_lock, flags);
4062 tty_kref_put(tty);
4063}
4064
4065
4066
4067
4068
4069
4070
4071static void stl_sc26198sendflow(struct stlport *portp, int state)
4072{
4073 struct tty_struct *tty;
4074 unsigned long flags;
4075 unsigned char mr0;
4076
4077 pr_debug("stl_sc26198sendflow(portp=%p,state=%x)\n", portp, state);
4078
4079 if (portp == NULL)
4080 return;
4081 tty = tty_port_tty_get(&portp->port);
4082 if (tty == NULL)
4083 return;
4084
4085 spin_lock_irqsave(&brd_lock, flags);
4086 BRDENABLE(portp->brdnr, portp->pagenr);
4087 if (state) {
4088 mr0 = stl_sc26198getreg(portp, MR0);
4089 stl_sc26198setreg(portp, MR0, (mr0 & ~MR0_SWFRXTX));
4090 stl_sc26198setreg(portp, SCCR, CR_TXSENDXON);
4091 mr0 |= MR0_SWFRX;
4092 portp->stats.rxxon++;
4093 stl_sc26198wait(portp);
4094 stl_sc26198setreg(portp, MR0, mr0);
4095 } else {
4096 mr0 = stl_sc26198getreg(portp, MR0);
4097 stl_sc26198setreg(portp, MR0, (mr0 & ~MR0_SWFRXTX));
4098 stl_sc26198setreg(portp, SCCR, CR_TXSENDXOFF);
4099 mr0 &= ~MR0_SWFRX;
4100 portp->stats.rxxoff++;
4101 stl_sc26198wait(portp);
4102 stl_sc26198setreg(portp, MR0, mr0);
4103 }
4104 BRDDISABLE(portp->brdnr);
4105 spin_unlock_irqrestore(&brd_lock, flags);
4106 tty_kref_put(tty);
4107}
4108
4109
4110
4111static void stl_sc26198flush(struct stlport *portp)
4112{
4113 unsigned long flags;
4114
4115 pr_debug("stl_sc26198flush(portp=%p)\n", portp);
4116
4117 if (portp == NULL)
4118 return;
4119
4120 spin_lock_irqsave(&brd_lock, flags);
4121 BRDENABLE(portp->brdnr, portp->pagenr);
4122 stl_sc26198setreg(portp, SCCR, CR_TXRESET);
4123 stl_sc26198setreg(portp, SCCR, portp->crenable);
4124 BRDDISABLE(portp->brdnr);
4125 portp->tx.tail = portp->tx.head;
4126 spin_unlock_irqrestore(&brd_lock, flags);
4127}
4128
4129
4130
4131
4132
4133
4134
4135
4136
4137
4138
4139static int stl_sc26198datastate(struct stlport *portp)
4140{
4141 unsigned long flags;
4142 unsigned char sr;
4143
4144 pr_debug("stl_sc26198datastate(portp=%p)\n", portp);
4145
4146 if (portp == NULL)
4147 return 0;
4148 if (test_bit(ASYI_TXBUSY, &portp->istate))
4149 return 1;
4150
4151 spin_lock_irqsave(&brd_lock, flags);
4152 BRDENABLE(portp->brdnr, portp->pagenr);
4153 sr = stl_sc26198getreg(portp, SR);
4154 BRDDISABLE(portp->brdnr);
4155 spin_unlock_irqrestore(&brd_lock, flags);
4156
4157 return (sr & SR_TXEMPTY) ? 0 : 1;
4158}
4159
4160
4161
4162
4163
4164
4165
4166
4167static void stl_sc26198wait(struct stlport *portp)
4168{
4169 int i;
4170
4171 pr_debug("stl_sc26198wait(portp=%p)\n", portp);
4172
4173 if (portp == NULL)
4174 return;
4175
4176 for (i = 0; i < 20; i++)
4177 stl_sc26198getglobreg(portp, TSTR);
4178}
4179
4180
4181
4182
4183
4184
4185
4186
4187
4188static void stl_sc26198txunflow(struct stlport *portp, struct tty_struct *tty)
4189{
4190 unsigned char mr0;
4191
4192 mr0 = stl_sc26198getreg(portp, MR0);
4193 stl_sc26198setreg(portp, MR0, (mr0 & ~MR0_SWFRXTX));
4194 stl_sc26198setreg(portp, SCCR, CR_HOSTXON);
4195 stl_sc26198wait(portp);
4196 stl_sc26198setreg(portp, MR0, mr0);
4197 clear_bit(ASYI_TXFLOWED, &portp->istate);
4198}
4199
4200
4201
4202
4203
4204
4205
4206static void stl_sc26198intr(struct stlpanel *panelp, unsigned int iobase)
4207{
4208 struct stlport *portp;
4209 unsigned int iack;
4210
4211 spin_lock(&brd_lock);
4212
4213
4214
4215
4216
4217 outb(0, (iobase + 1));
4218
4219 iack = inb(iobase + XP_IACK);
4220 portp = panelp->ports[(iack & IVR_CHANMASK) + ((iobase & 0x4) << 1)];
4221
4222 if (iack & IVR_RXDATA)
4223 stl_sc26198rxisr(portp, iack);
4224 else if (iack & IVR_TXDATA)
4225 stl_sc26198txisr(portp);
4226 else
4227 stl_sc26198otherisr(portp, iack);
4228
4229 spin_unlock(&brd_lock);
4230}
4231
4232
4233
4234
4235
4236
4237
4238
4239
4240
4241
4242
4243
4244static void stl_sc26198txisr(struct stlport *portp)
4245{
4246 struct tty_struct *tty;
4247 unsigned int ioaddr;
4248 unsigned char mr0;
4249 int len, stlen;
4250 char *head, *tail;
4251
4252 pr_debug("stl_sc26198txisr(portp=%p)\n", portp);
4253
4254 ioaddr = portp->ioaddr;
4255 head = portp->tx.head;
4256 tail = portp->tx.tail;
4257 len = (head >= tail) ? (head - tail) : (STL_TXBUFSIZE - (tail - head));
4258 if ((len == 0) || ((len < STL_TXBUFLOW) &&
4259 (test_bit(ASYI_TXLOW, &portp->istate) == 0))) {
4260 set_bit(ASYI_TXLOW, &portp->istate);
4261 tty = tty_port_tty_get(&portp->port);
4262 if (tty) {
4263 tty_wakeup(tty);
4264 tty_kref_put(tty);
4265 }
4266 }
4267
4268 if (len == 0) {
4269 outb((MR0 | portp->uartaddr), (ioaddr + XP_ADDR));
4270 mr0 = inb(ioaddr + XP_DATA);
4271 if ((mr0 & MR0_TXMASK) == MR0_TXEMPTY) {
4272 portp->imr &= ~IR_TXRDY;
4273 outb((IMR | portp->uartaddr), (ioaddr + XP_ADDR));
4274 outb(portp->imr, (ioaddr + XP_DATA));
4275 clear_bit(ASYI_TXBUSY, &portp->istate);
4276 } else {
4277 mr0 |= ((mr0 & ~MR0_TXMASK) | MR0_TXEMPTY);
4278 outb(mr0, (ioaddr + XP_DATA));
4279 }
4280 } else {
4281 len = min(len, SC26198_TXFIFOSIZE);
4282 portp->stats.txtotal += len;
4283 stlen = min_t(unsigned int, len,
4284 (portp->tx.buf + STL_TXBUFSIZE) - tail);
4285 outb(GTXFIFO, (ioaddr + XP_ADDR));
4286 outsb((ioaddr + XP_DATA), tail, stlen);
4287 len -= stlen;
4288 tail += stlen;
4289 if (tail >= (portp->tx.buf + STL_TXBUFSIZE))
4290 tail = portp->tx.buf;
4291 if (len > 0) {
4292 outsb((ioaddr + XP_DATA), tail, len);
4293 tail += len;
4294 }
4295 portp->tx.tail = tail;
4296 }
4297}
4298
4299
4300
4301
4302
4303
4304
4305
4306
4307
4308
4309
4310
4311static void stl_sc26198rxisr(struct stlport *portp, unsigned int iack)
4312{
4313 struct tty_struct *tty;
4314 unsigned int len, buflen, ioaddr;
4315
4316 pr_debug("stl_sc26198rxisr(portp=%p,iack=%x)\n", portp, iack);
4317
4318 tty = tty_port_tty_get(&portp->port);
4319 ioaddr = portp->ioaddr;
4320 outb(GIBCR, (ioaddr + XP_ADDR));
4321 len = inb(ioaddr + XP_DATA) + 1;
4322
4323 if ((iack & IVR_TYPEMASK) == IVR_RXDATA) {
4324 if (tty == NULL || (buflen = tty_buffer_request_room(tty, len)) == 0) {
4325 len = min_t(unsigned int, len, sizeof(stl_unwanted));
4326 outb(GRXFIFO, (ioaddr + XP_ADDR));
4327 insb((ioaddr + XP_DATA), &stl_unwanted[0], len);
4328 portp->stats.rxlost += len;
4329 portp->stats.rxtotal += len;
4330 } else {
4331 len = min(len, buflen);
4332 if (len > 0) {
4333 unsigned char *ptr;
4334 outb(GRXFIFO, (ioaddr + XP_ADDR));
4335 tty_prepare_flip_string(tty, &ptr, len);
4336 insb((ioaddr + XP_DATA), ptr, len);
4337 tty_schedule_flip(tty);
4338 portp->stats.rxtotal += len;
4339 }
4340 }
4341 } else {
4342 stl_sc26198rxbadchars(portp);
4343 }
4344
4345
4346
4347
4348
4349
4350 if (test_bit(ASYI_TXFLOWED, &portp->istate)) {
4351 if ((tty != NULL) &&
4352 (tty->termios != NULL) &&
4353 (tty->termios->c_iflag & IXANY)) {
4354 stl_sc26198txunflow(portp, tty);
4355 }
4356 }
4357 tty_kref_put(tty);
4358}
4359
4360
4361
4362
4363
4364
4365
4366static void stl_sc26198rxbadch(struct stlport *portp, unsigned char status, char ch)
4367{
4368 struct tty_struct *tty;
4369 unsigned int ioaddr;
4370
4371 tty = tty_port_tty_get(&portp->port);
4372 ioaddr = portp->ioaddr;
4373
4374 if (status & SR_RXPARITY)
4375 portp->stats.rxparity++;
4376 if (status & SR_RXFRAMING)
4377 portp->stats.rxframing++;
4378 if (status & SR_RXOVERRUN)
4379 portp->stats.rxoverrun++;
4380 if (status & SR_RXBREAK)
4381 portp->stats.rxbreaks++;
4382
4383 if ((tty != NULL) &&
4384 ((portp->rxignoremsk & status) == 0)) {
4385 if (portp->rxmarkmsk & status) {
4386 if (status & SR_RXBREAK) {
4387 status = TTY_BREAK;
4388 if (portp->port.flags & ASYNC_SAK) {
4389 do_SAK(tty);
4390 BRDENABLE(portp->brdnr, portp->pagenr);
4391 }
4392 } else if (status & SR_RXPARITY)
4393 status = TTY_PARITY;
4394 else if (status & SR_RXFRAMING)
4395 status = TTY_FRAME;
4396 else if(status & SR_RXOVERRUN)
4397 status = TTY_OVERRUN;
4398 else
4399 status = 0;
4400 } else
4401 status = 0;
4402
4403 tty_insert_flip_char(tty, ch, status);
4404 tty_schedule_flip(tty);
4405
4406 if (status == 0)
4407 portp->stats.rxtotal++;
4408 }
4409 tty_kref_put(tty);
4410}
4411
4412
4413
4414
4415
4416
4417
4418
4419
4420
4421
4422
4423static void stl_sc26198rxbadchars(struct stlport *portp)
4424{
4425 unsigned char status, mr1;
4426 char ch;
4427
4428
4429
4430
4431
4432 mr1 = stl_sc26198getreg(portp, MR1);
4433 stl_sc26198setreg(portp, MR1, (mr1 & ~MR1_ERRBLOCK));
4434
4435 while ((status = stl_sc26198getreg(portp, SR)) & SR_RXRDY) {
4436 stl_sc26198setreg(portp, SCCR, CR_CLEARRXERR);
4437 ch = stl_sc26198getreg(portp, RXFIFO);
4438 stl_sc26198rxbadch(portp, status, ch);
4439 }
4440
4441
4442
4443
4444
4445 stl_sc26198setreg(portp, MR1, mr1);
4446}
4447
4448
4449
4450
4451
4452
4453
4454
4455
4456static void stl_sc26198otherisr(struct stlport *portp, unsigned int iack)
4457{
4458 unsigned char cir, ipr, xisr;
4459
4460 pr_debug("stl_sc26198otherisr(portp=%p,iack=%x)\n", portp, iack);
4461
4462 cir = stl_sc26198getglobreg(portp, CIR);
4463
4464 switch (cir & CIR_SUBTYPEMASK) {
4465 case CIR_SUBCOS:
4466 ipr = stl_sc26198getreg(portp, IPR);
4467 if (ipr & IPR_DCDCHANGE) {
4468 stl_cd_change(portp);
4469 portp->stats.modem++;
4470 }
4471 break;
4472 case CIR_SUBXONXOFF:
4473 xisr = stl_sc26198getreg(portp, XISR);
4474 if (xisr & XISR_RXXONGOT) {
4475 set_bit(ASYI_TXFLOWED, &portp->istate);
4476 portp->stats.txxoff++;
4477 }
4478 if (xisr & XISR_RXXOFFGOT) {
4479 clear_bit(ASYI_TXFLOWED, &portp->istate);
4480 portp->stats.txxon++;
4481 }
4482 break;
4483 case CIR_SUBBREAK:
4484 stl_sc26198setreg(portp, SCCR, CR_BREAKRESET);
4485 stl_sc26198rxbadchars(portp);
4486 break;
4487 default:
4488 break;
4489 }
4490}
4491
4492static void stl_free_isabrds(void)
4493{
4494 struct stlbrd *brdp;
4495 unsigned int i;
4496
4497 for (i = 0; i < stl_nrbrds; i++) {
4498 if ((brdp = stl_brds[i]) == NULL || (brdp->state & STL_PROBED))
4499 continue;
4500
4501 free_irq(brdp->irq, brdp);
4502
4503 stl_cleanup_panels(brdp);
4504
4505 release_region(brdp->ioaddr1, brdp->iosize1);
4506 if (brdp->iosize2 > 0)
4507 release_region(brdp->ioaddr2, brdp->iosize2);
4508
4509 kfree(brdp);
4510 stl_brds[i] = NULL;
4511 }
4512}
4513
4514
4515
4516
4517static int __init stallion_module_init(void)
4518{
4519 struct stlbrd *brdp;
4520 struct stlconf conf;
4521 unsigned int i, j;
4522 int retval;
4523
4524 printk(KERN_INFO "%s: version %s\n", stl_drvtitle, stl_drvversion);
4525
4526 spin_lock_init(&stallion_lock);
4527 spin_lock_init(&brd_lock);
4528
4529 stl_serial = alloc_tty_driver(STL_MAXBRDS * STL_MAXPORTS);
4530 if (!stl_serial) {
4531 retval = -ENOMEM;
4532 goto err;
4533 }
4534
4535 stl_serial->owner = THIS_MODULE;
4536 stl_serial->driver_name = stl_drvname;
4537 stl_serial->name = "ttyE";
4538 stl_serial->major = STL_SERIALMAJOR;
4539 stl_serial->minor_start = 0;
4540 stl_serial->type = TTY_DRIVER_TYPE_SERIAL;
4541 stl_serial->subtype = SERIAL_TYPE_NORMAL;
4542 stl_serial->init_termios = stl_deftermios;
4543 stl_serial->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
4544 tty_set_operations(stl_serial, &stl_ops);
4545
4546 retval = tty_register_driver(stl_serial);
4547 if (retval) {
4548 printk("STALLION: failed to register serial driver\n");
4549 goto err_frtty;
4550 }
4551
4552
4553
4554
4555
4556 for (i = stl_nrbrds; i < stl_nargs; i++) {
4557 memset(&conf, 0, sizeof(conf));
4558 if (stl_parsebrd(&conf, stl_brdsp[i]) == 0)
4559 continue;
4560 if ((brdp = stl_allocbrd()) == NULL)
4561 continue;
4562 brdp->brdnr = i;
4563 brdp->brdtype = conf.brdtype;
4564 brdp->ioaddr1 = conf.ioaddr1;
4565 brdp->ioaddr2 = conf.ioaddr2;
4566 brdp->irq = conf.irq;
4567 brdp->irqtype = conf.irqtype;
4568 stl_brds[brdp->brdnr] = brdp;
4569 if (stl_brdinit(brdp)) {
4570 stl_brds[brdp->brdnr] = NULL;
4571 kfree(brdp);
4572 } else {
4573 for (j = 0; j < brdp->nrports; j++)
4574 tty_register_device(stl_serial,
4575 brdp->brdnr * STL_MAXPORTS + j, NULL);
4576 stl_nrbrds = i + 1;
4577 }
4578 }
4579
4580
4581 retval = pci_register_driver(&stl_pcidriver);
4582 if (retval && stl_nrbrds == 0) {
4583 printk(KERN_ERR "STALLION: can't register pci driver\n");
4584 goto err_unrtty;
4585 }
4586
4587
4588
4589
4590
4591 if (register_chrdev(STL_SIOMEMMAJOR, "staliomem", &stl_fsiomem))
4592 printk("STALLION: failed to register serial board device\n");
4593
4594 stallion_class = class_create(THIS_MODULE, "staliomem");
4595 if (IS_ERR(stallion_class))
4596 printk("STALLION: failed to create class\n");
4597 for (i = 0; i < 4; i++)
4598 device_create(stallion_class, NULL, MKDEV(STL_SIOMEMMAJOR, i),
4599 NULL, "staliomem%d", i);
4600
4601 return 0;
4602err_unrtty:
4603 tty_unregister_driver(stl_serial);
4604err_frtty:
4605 put_tty_driver(stl_serial);
4606err:
4607 return retval;
4608}
4609
4610static void __exit stallion_module_exit(void)
4611{
4612 struct stlbrd *brdp;
4613 unsigned int i, j;
4614
4615 pr_debug("cleanup_module()\n");
4616
4617 printk(KERN_INFO "Unloading %s: version %s\n", stl_drvtitle,
4618 stl_drvversion);
4619
4620
4621
4622
4623
4624
4625
4626 for (i = 0; i < stl_nrbrds; i++) {
4627 if ((brdp = stl_brds[i]) == NULL || (brdp->state & STL_PROBED))
4628 continue;
4629 for (j = 0; j < brdp->nrports; j++)
4630 tty_unregister_device(stl_serial,
4631 brdp->brdnr * STL_MAXPORTS + j);
4632 }
4633
4634 for (i = 0; i < 4; i++)
4635 device_destroy(stallion_class, MKDEV(STL_SIOMEMMAJOR, i));
4636 unregister_chrdev(STL_SIOMEMMAJOR, "staliomem");
4637 class_destroy(stallion_class);
4638
4639 pci_unregister_driver(&stl_pcidriver);
4640
4641 stl_free_isabrds();
4642
4643 tty_unregister_driver(stl_serial);
4644 put_tty_driver(stl_serial);
4645}
4646
4647module_init(stallion_module_init);
4648module_exit(stallion_module_exit);
4649
4650MODULE_AUTHOR("Greg Ungerer");
4651MODULE_DESCRIPTION("Stallion Multiport Serial Driver");
4652MODULE_LICENSE("GPL");
4653
