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