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