gold: Fix hardcoded library search path
[dragonfly.git] / sys / platform / pc32 / gnu / isa / dgb.c
1 /*-
2  * (MPSAFE)
3  *
4  *  dgb.c $FreeBSD: src/sys/gnu/i386/isa/dgb.c,v 1.56.2.1 2001/02/26 04:23:09 jlemon Exp $
5  *  dgb.c $DragonFly: src/sys/platform/pc32/gnu/isa/dgb.c,v 1.20 2008/08/02 01:14:43 dillon Exp $
6  *
7  *  Digiboard driver.
8  *
9  *  Stage 1. "Better than nothing".
10  *  Stage 2. "Gee, it works!".
11  *
12  *  Based on sio driver by Bruce Evans and on Linux driver by Troy 
13  *  De Jongh <troyd@digibd.com> or <troyd@skypoint.com> 
14  *  which is under GNU General Public License version 2 so this driver 
15  *  is forced to be under GPL 2 too.
16  *
17  *  Written by Serge Babkin,
18  *      Joint Stock Commercial Bank "Chelindbank"
19  *      (Chelyabinsk, Russia)
20  *      babkin@hq.icb.chel.su
21  *
22  *  Assorted hacks to make it more functional and working under 3.0-current.
23  *  Fixed broken routines to prevent processes hanging on closed (thanks
24  *  to Bruce for his patience and assistance). Thanks also to Maxim Bolotin
25  *  <max@run.net> for his patches which did most of the work to get this
26  *  running under 2.2/3.0-current.
27  *  Implemented ioctls: TIOCMSDTRWAIT, TIOCMGDTRWAIT, TIOCTIMESTAMP &
28  *  TIOCDCDTIMESTAMP.
29  *  Sysctl debug flag is now a bitflag, to filter noise during debugging.
30  *      David L. Nugent <davidn@blaze.net.au>
31  */
32
33 #include "opt_compat.h"
34 #include "opt_dgb.h"
35 #include "opt_deprecated.h"
36 #ifndef I_WANT_DEPRECATED_STUFF
37 #error "Add options I_WANT_DEPRECATED_STUFF to your kernel config and send a mail to kernel@"
38 #endif
39
40 #include "use_dgb.h"
41
42 /* Helg: i.e.25 times per sec board will be polled */
43 #define POLLSPERSEC 25
44 /* How many charactes can we write to input tty rawq */
45 #define DGB_IBUFSIZE (TTYHOG-100)
46
47 /* the overall number of ports controlled by this driver */
48
49 #ifndef NDGBPORTS
50 #       define NDGBPORTS (NDGB*16)
51 #endif
52
53 #include <sys/param.h>
54 #include <sys/systm.h>
55 #include <sys/tty.h>
56 #include <sys/proc.h>
57 #include <sys/priv.h>
58 #include <sys/conf.h>
59 #include <sys/dkstat.h>
60 #include <sys/fcntl.h>
61 #include <sys/kernel.h>
62 #include <sys/sysctl.h>
63 #include <sys/thread2.h>
64
65 #include <machine/clock.h>
66
67 #include <vm/vm.h>
68 #include <vm/pmap.h>
69
70 #include <bus/isa/isa_device.h>
71
72 #include "dgbios.h"
73 #include "dgfep.h"
74
75 #define DGB_DEBUG               /* Enable debugging info via sysctl */
76 #include "dgreg.h"
77
78 #define CALLOUT_MASK            0x80
79 #define CONTROL_MASK            0x60
80 #define CONTROL_INIT_STATE      0x20
81 #define CONTROL_LOCK_STATE      0x40
82 #define UNIT_MASK                       0x30000
83 #define PORT_MASK                       0x1F
84 #define DEV_TO_UNIT(dev)        (MINOR_TO_UNIT(minor(dev)))
85 #define MINOR_MAGIC_MASK        (CALLOUT_MASK | CONTROL_MASK)
86 #define MINOR_TO_UNIT(mynor)    (((mynor) & UNIT_MASK)>>16)
87 #define MINOR_TO_PORT(mynor)    ((mynor) & PORT_MASK)
88
89 /* types.  XXX - should be elsewhere */
90 typedef u_char  bool_t;         /* boolean */
91
92 /* digiboard port structure */
93 struct dgb_p {
94         bool_t  status;
95
96         u_char unit;           /* board unit number */
97         u_char pnum;           /* port number */
98         u_char omodem;         /* FEP output modem status     */
99         u_char imodem;         /* FEP input modem status      */
100         u_char modemfake;      /* Modem values to be forced   */
101         u_char modem;          /* Force values                */
102         u_char hflow;
103         u_char dsr;
104         u_char dcd;
105         u_char stopc;
106         u_char startc;
107         u_char stopca;
108         u_char startca;
109         u_char fepstopc;
110         u_char fepstartc;
111         u_char fepstopca;
112         u_char fepstartca;
113         u_char txwin;
114         u_char rxwin;
115         ushort fepiflag;
116         ushort fepcflag;
117         ushort fepoflag;
118         ushort txbufhead;
119         ushort txbufsize;
120         ushort rxbufhead;
121         ushort rxbufsize;
122         int close_delay;
123         int count;
124         int blocked_open;
125         int event;
126         int asyncflags;
127         u_long statusflags;
128         volatile u_char *txptr;
129         volatile u_char *rxptr;
130         volatile struct board_chan *brdchan;
131         struct tty *tty;
132
133         bool_t  active_out;     /* nonzero if the callout device is open */
134         u_int   wopeners;       /* # processes waiting for DCD in open() */
135
136         /* Initial state. */
137         struct termios  it_in;  /* should be in struct tty */
138         struct termios  it_out;
139
140         /* Lock state. */
141         struct termios  lt_in;  /* should be in struct tty */
142         struct termios  lt_out;
143
144         bool_t  do_timestamp;
145         bool_t  do_dcd_timestamp;
146         struct timeval  timestamp;
147         struct timeval  dcd_timestamp;
148
149         /* flags of state, are used in sleep() too */
150         u_char closing; /* port is being closed now */
151         u_char draining; /* port is being drained now */
152         u_char used;    /* port is being used now */
153         u_char mustdrain; /* data must be waited to drain in dgbparam() */
154 };
155
156 /* Digiboard per-board structure */
157 struct dgb_softc {
158         /* struct board_info */
159         u_char status;  /* status: DISABLED/ENABLED */
160         u_char unit;    /* unit number */
161         u_char type;    /* type of card: PCXE, PCXI, PCXEVE */
162         u_char altpin;  /* do we need alternate pin setting ? */
163         int numports;   /* number of ports on card */
164         int port;       /* I/O port */
165         u_char *vmem; /* virtual memory address */
166         long pmem; /* physical memory address */
167         int mem_seg;  /* internal memory segment */
168         struct dgb_p *ports;    /* pointer to array of port descriptors */
169         struct tty *ttys;       /* pointer to array of TTY structures */
170         volatile struct global_data *mailbox;
171         struct callout dgb_pause;
172         struct callout dgbpoll;
173         struct callout wakeflush;
174         };
175         
176
177 static struct dgb_softc dgb_softc[NDGB];
178 static struct dgb_p dgb_ports[NDGBPORTS];
179 static struct tty dgb_tty[NDGBPORTS];
180
181 /*
182  * The public functions in the com module ought to be declared in a com-driver
183  * system header.
184  */
185
186 /* Interrupt handling entry points. */
187 static void     dgbpoll         (void *unit_c);
188
189 /* Device switch entry points. */
190 #define dgbreset        noreset
191 #define dgbmmap         nommap
192 #define dgbstrategy     nostrategy
193
194 static  int     dgbattach       (struct isa_device *dev);
195 static  int     dgbprobe        (struct isa_device *dev);
196
197 static void fepcmd(struct dgb_p *port, unsigned cmd, unsigned op1, unsigned op2,
198         unsigned ncmds, unsigned bytecmd);
199
200 static  void    dgbstart        (struct tty *tp);
201 static  void    dgbstop         (struct tty *tp, int rw);
202 static  int     dgbparam        (struct tty *tp, struct termios *t);
203 static  void    dgbhardclose    (struct dgb_p *port);
204 static  void    dgb_drain_or_flush      (struct dgb_p *port);
205 static  int     dgbdrain        (struct dgb_p *port);
206 static  void    dgb_pause       (void *chan);
207 static  void    wakeflush       (void *p);
208 static  void    disc_optim      (struct tty     *tp, struct termios *t);
209
210
211 struct isa_driver       dgbdriver = {
212         dgbprobe, dgbattach, "dgb",0
213 };
214
215 static  d_open_t        dgbopen;
216 static  d_close_t       dgbclose;
217 static  d_ioctl_t       dgbioctl;
218
219 #define CDEV_MAJOR      58
220 static struct cdevsw dgb_cdevsw = {
221         /* name */      "dgb",
222         /* maj */       CDEV_MAJOR,
223         /* flags */     D_TTY,
224         /* port */      NULL,
225         /* clone */     NULL,
226
227         /* open */      dgbopen,
228         /* close */     dgbclose,
229         /* read */      ttyread,
230         /* write */     ttywrite,
231         /* ioctl */     dgbioctl,
232         /* mmap */      nommap,
233         /* strategy */  nostrategy,
234         /* dump */      nodump,
235         /* psize */     nopsize,
236         /* kqfilter */  ttykqfilter
237 };
238
239 static  speed_t dgbdefaultrate = TTYDEF_SPEED;
240
241 static  struct speedtab dgbspeedtab[] = {
242         { 0,            FEP_B0 }, /* old (sysV-like) Bx codes */
243         { 50,           FEP_B50 },
244         { 75,           FEP_B75 },
245         { 110,          FEP_B110 },
246         { 134,          FEP_B134 },
247         { 150,          FEP_B150 },
248         { 200,          FEP_B200 },
249         { 300,          FEP_B300 },
250         { 600,          FEP_B600 },
251         { 1200,         FEP_B1200 },
252         { 1800,         FEP_B1800 },
253         { 2400,         FEP_B2400 },
254         { 4800,         FEP_B4800 },
255         { 9600,         FEP_B9600 },
256         { 19200,        FEP_B19200 },
257         { 38400,        FEP_B38400 },
258         { 57600,        (FEP_FASTBAUD|FEP_B50) }, /* B50 & fast baud table */
259         { 115200, (FEP_FASTBAUD|FEP_B110) }, /* B100 & fast baud table */
260         { -1,   -1 }
261 };
262
263 static struct dbgflagtbl
264 {
265   tcflag_t in_mask;
266   tcflag_t in_val;
267   tcflag_t out_val;
268 } dgb_cflags[] =
269 {
270   { PARODD,   PARODD,     FEP_PARODD  },
271   { PARENB,   PARENB,     FEP_PARENB  },
272   { CSTOPB,   CSTOPB,     FEP_CSTOPB  },
273   { CSIZE,    CS5,        FEP_CS6     },
274   { CSIZE,    CS6,        FEP_CS6     },
275   { CSIZE,    CS7,        FEP_CS7     },
276   { CSIZE,    CS8,        FEP_CS8     },
277   { CLOCAL,   CLOCAL,     FEP_CLOCAL  },
278   { (tcflag_t)-1 }
279 }, dgb_iflags[] =
280 {
281   { IGNBRK,   IGNBRK,     FEP_IGNBRK  },
282   { BRKINT,   BRKINT,     FEP_BRKINT  },
283   { IGNPAR,   IGNPAR,     FEP_IGNPAR  },
284   { PARMRK,   PARMRK,     FEP_PARMRK  },
285   { INPCK,    INPCK,      FEP_INPCK   },
286   { ISTRIP,   ISTRIP,     FEP_ISTRIP  },
287   { IXON,     IXON,       FEP_IXON    },
288   { IXOFF,    IXOFF,      FEP_IXOFF   },
289   { IXANY,    IXANY,      FEP_IXANY   },
290   { (tcflag_t)-1 }
291 }, dgb_flow[] =
292 {
293   { CRTSCTS,  CRTSCTS,    CTS|RTS     },
294   { CRTSCTS,  CCTS_OFLOW, CTS         },
295   { CRTSCTS,  CRTS_IFLOW, RTS         },
296   { (tcflag_t)-1 }
297 };
298
299 /* xlat bsd termios flags to dgb sys-v style */
300 static tcflag_t
301 dgbflags(struct dbgflagtbl *tbl, tcflag_t input)
302 {
303   tcflag_t output = 0;
304   int i;
305
306   for (i=0; tbl[i].in_mask != (tcflag_t)-1; i++)
307   {
308     if ((input & tbl[i].in_mask) == tbl[i].in_val)
309       output |= tbl[i].out_val;
310   }
311   return output;
312 }
313
314 #ifdef DGB_DEBUG
315 static int dgbdebug=0;
316 SYSCTL_INT(_debug, OID_AUTO, dgb_debug, CTLFLAG_RW, &dgbdebug, 0, "");
317 #endif
318
319 static __inline int setwin (struct dgb_softc *sc, unsigned addr);
320 static __inline int setinitwin (struct dgb_softc *sc, unsigned addr);
321 static __inline void hidewin (struct dgb_softc *sc);
322 static __inline void towin (struct dgb_softc *sc, int win);
323
324 /*Helg: to allow recursive dgb...() calls */
325 typedef struct
326   {                 /* If we were called and don't want to disturb we need: */
327         int port;               /* write to this port */
328         u_char data;            /* this data on exit */
329                           /* or DATA_WINOFF  to close memory window on entry */
330   } BoardMemWinState; /* so several channels and even boards can coexist */
331 #define DATA_WINOFF 0
332 static BoardMemWinState bmws;
333
334 /* return current memory window state and close window */
335 static BoardMemWinState
336 bmws_get(void)
337 {
338         BoardMemWinState bmwsRet=bmws;
339         if(bmws.data!=DATA_WINOFF)
340                 outb(bmws.port, bmws.data=DATA_WINOFF);
341         return bmwsRet;
342 }
343
344 /* restore memory window state */
345 static void
346 bmws_set(BoardMemWinState ws)
347 {
348         if(ws.data != bmws.data || ws.port!=bmws.port ) {
349                 if(bmws.data!=DATA_WINOFF)
350                         outb(bmws.port,DATA_WINOFF);
351                 if(ws.data!=DATA_WINOFF)
352                         outb(ws.port, ws.data);
353                 bmws=ws;
354         }
355 }
356
357 static __inline int 
358 setwin(sc,addr)
359         struct dgb_softc *sc;
360         unsigned int addr;
361 {
362         if(sc->type==PCXEVE) {
363                 outb(bmws.port=sc->port+1, bmws.data=FEPWIN|(addr>>13));
364                 DPRINT3(DB_WIN,"dgb%d: switched to window 0x%x\n",sc->unit,addr>>13);
365                 return (addr & 0x1FFF);
366         } else {
367                 outb(bmws.port=sc->port,bmws.data=FEPMEM);
368                 return addr;
369         }
370 }
371
372 static __inline int 
373 setinitwin(sc,addr)
374         struct dgb_softc *sc;
375         unsigned int addr;
376 {
377         if(sc->type==PCXEVE) {
378                 outb(bmws.port=sc->port+1, bmws.data=FEPWIN|(addr>>13));
379                 DPRINT3(DB_WIN,"dgb%d: switched to window 0x%x\n",sc->unit,addr>>13);
380                 return (addr & 0x1FFF);
381         } else {
382                 outb(bmws.port=sc->port,bmws.data=inb(sc->port)|FEPMEM);
383                 return addr;
384         }
385 }
386
387 static __inline void
388 hidewin(sc)
389         struct dgb_softc *sc;
390 {
391         bmws.data=0;
392         if(sc->type==PCXEVE)
393                 outb(bmws.port=sc->port+1, bmws.data);
394         else
395                 outb(bmws.port=sc->port, bmws.data);
396 }
397
398 static __inline void
399 towin(sc,win)
400         struct dgb_softc *sc;
401         int win;
402 {
403         if(sc->type==PCXEVE) {
404                 outb(bmws.port=sc->port+1, bmws.data=win);
405         } else {
406                 outb(bmws.port=sc->port,bmws.data=FEPMEM);
407         }
408 }
409
410 static int
411 dgbprobe(dev)
412         struct isa_device       *dev;
413 {
414         struct dgb_softc *sc= &dgb_softc[dev->id_unit];
415         int i, v;
416         u_long win_size;  /* size of vizible memory window */
417         int unit=dev->id_unit;
418
419         lwkt_gettoken(&tty_token);
420         sc->unit=dev->id_unit;
421         sc->port=dev->id_iobase;
422
423         if(dev->id_flags & DGBFLAG_ALTPIN)
424                 sc->altpin=1;
425         else
426                 sc->altpin=0;
427
428         /* left 24 bits only (ISA address) */
429         sc->pmem=((intptr_t)(void *)dev->id_maddr & 0xFFFFFF); 
430         
431         DPRINT4(DB_INFO,"dgb%d: port 0x%x mem 0x%lx\n",unit,sc->port,sc->pmem);
432
433         outb(sc->port, FEPRST);
434         sc->status=DISABLED;
435
436         for(i=0; i< 1000; i++) {
437                 DELAY(1);
438                 if( (inb(sc->port) & FEPMASK) == FEPRST ) {
439                         sc->status=ENABLED;
440                         DPRINT3(DB_EXCEPT,"dgb%d: got reset after %d us\n",unit,i);
441                         break;
442                 }
443         }
444
445         if(sc->status!=ENABLED) {
446                 DPRINT2(DB_EXCEPT,"dgb%d: failed to respond\n",dev->id_unit);
447                 lwkt_reltoken(&tty_token);
448                 return 0;
449         }
450
451         /* check type of card and get internal memory characteristics */
452
453         v=inb(sc->port);
454
455         if( v & 0x1 ) {
456                 switch( v&0x30 ) {
457                 case 0:
458                         sc->mem_seg=0xF000;
459                         win_size=0x10000;
460                         kprintf("dgb%d: PC/Xi 64K\n",dev->id_unit);
461                         break;
462                 case 0x10:
463                         sc->mem_seg=0xE000;
464                         win_size=0x20000;
465                         kprintf("dgb%d: PC/Xi 128K\n",dev->id_unit);
466                         break;
467                 case 0x20:
468                         sc->mem_seg=0xC000;
469                         win_size=0x40000;
470                         kprintf("dgb%d: PC/Xi 256K\n",dev->id_unit);
471                         break;
472                 default: /* case 0x30: */
473                         sc->mem_seg=0x8000;
474                         win_size=0x80000;
475                         kprintf("dgb%d: PC/Xi 512K\n",dev->id_unit);
476                         break;
477                 }
478                 sc->type=PCXI;
479         } else {
480                 outb(sc->port, 1);
481                 v=inb(sc->port);
482
483                 if( v & 0x1 ) {
484                         kprintf("dgb%d: PC/Xm isn't supported\n",dev->id_unit);
485                         sc->status=DISABLED;
486                         lwkt_reltoken(&tty_token);
487                         return 0;
488                         }
489
490                 sc->mem_seg=0xF000;
491
492                 if(dev->id_flags==DGBFLAG_NOWIN || ( v&0xC0 )==0) {
493                         win_size=0x10000;
494                         kprintf("dgb%d: PC/Xe 64K\n",dev->id_unit);
495                         sc->type=PCXE;
496                 } else {
497                         win_size=0x2000;
498                         kprintf("dgb%d: PC/Xe 64/8K (windowed)\n",dev->id_unit);
499                         sc->type=PCXEVE;
500                         if((u_long)sc->pmem & ~0xFFE000) {
501                                 kprintf("dgb%d: warning: address 0x%lx truncated to 0x%lx\n",
502                                         dev->id_unit, sc->pmem,
503                                         sc->pmem & 0xFFE000);
504
505                                 dev->id_maddr= (u_char *)(void *)(intptr_t)( sc->pmem & 0xFFE000 );
506                         }
507                 }
508         }
509
510         /* save size of vizible memory segment */
511         dev->id_msize=win_size;
512
513         /* map memory */
514         dev->id_maddr=sc->vmem=pmap_mapdev(sc->pmem,dev->id_msize);
515
516         outb(sc->port, FEPCLR); /* drop RESET */
517         hidewin(sc); /* Helg: to set initial bmws state */
518
519         lwkt_reltoken(&tty_token);
520         return 4; /* we need I/O space of 4 ports */
521 }
522
523 static int
524 dgbattach(dev)
525         struct isa_device       *dev;
526 {
527         int unit=dev->id_unit;
528         struct dgb_softc *sc= &dgb_softc[dev->id_unit];
529         int i, t;
530         u_char volatile *mem;
531         u_char volatile *ptr;
532         int addr;
533         struct dgb_p *port;
534         volatile struct board_chan *bc;
535         int shrinkmem;
536         int nfails;
537         const volatile ushort *pstat;
538         int lowwater;
539         static int nports=0;
540         char suffix;
541
542         lwkt_gettoken(&tty_token);
543         if(sc->status!=ENABLED) {
544                 DPRINT2(DB_EXCEPT,"dbg%d: try to attach a disabled card\n",unit);
545                 lwkt_reltoken(&tty_token);
546                 return 0;
547                 }
548
549         callout_init_mp(&sc->dgb_pause);
550         callout_init_mp(&sc->dgbpoll);
551         callout_init_mp(&sc->wakeflush);
552
553         mem=sc->vmem;
554
555         DPRINT3(DB_INFO,"dgb%d: internal memory segment 0x%x\n",unit,sc->mem_seg);
556
557         outb(sc->port, FEPRST); DELAY(1);
558
559         for(i=0; (inb(sc->port) & FEPMASK) != FEPRST ; i++) {
560                 if(i>10000) {
561                         kprintf("dgb%d: 1st reset failed\n",dev->id_unit);
562                         sc->status=DISABLED;
563                         hidewin(sc);
564                         lwkt_reltoken(&tty_token);
565                         return 0;
566                 }
567                 DELAY(1);
568         }
569
570         DPRINT3(DB_INFO,"dgb%d: got reset after %d us\n",unit,i);
571
572         /* for PCXEVE set up interrupt and base address */
573
574         if(sc->type==PCXEVE) {
575                 t=(((u_long)sc->pmem>>8) & 0xFFE0) | 0x10 /* enable windowing */;
576                 /* IRQ isn't used */
577                 outb(sc->port+2,t & 0xFF);
578                 outb(sc->port+3,t>>8);
579         } else if(sc->type==PCXE) {
580                 t=(((u_long)sc->pmem>>8) & 0xFFE0) /* disable windowing */;
581                 outb(sc->port+2,t & 0xFF);
582                 outb(sc->port+3,t>>8);
583         }
584
585
586         if(sc->type==PCXI || sc->type==PCXE) {
587                 outb(sc->port, FEPRST|FEPMEM); DELAY(1);
588
589                 for(i=0; (inb(sc->port) & FEPMASK) != (FEPRST|FEPMEM) ; i++) {
590                         if(i>10000) {
591                                 kprintf("dgb%d: 2nd reset failed\n",dev->id_unit);
592                                 sc->status=DISABLED;
593                                 hidewin(sc);
594                                 lwkt_reltoken(&tty_token);
595                                 return 0;
596                         }
597                         DELAY(1);
598                 }
599
600                 DPRINT3(DB_INFO,"dgb%d: got memory after %d us\n",unit,i);
601         }
602
603         mem=sc->vmem;
604
605         /* very short memory test */
606
607         addr=setinitwin(sc,BOTWIN);
608         *(u_long volatile *)(mem+addr) = 0xA55A3CC3;
609         if(*(u_long volatile *)(mem+addr)!=0xA55A3CC3) {
610                 kprintf("dgb%d: 1st memory test failed\n",dev->id_unit);
611                 sc->status=DISABLED;
612                 hidewin(sc);
613                 lwkt_reltoken(&tty_token);
614                 return 0;
615         }
616                 
617         addr=setinitwin(sc,TOPWIN);
618         *(u_long volatile *)(mem+addr) = 0x5AA5C33C;
619         if(*(u_long volatile *)(mem+addr)!=0x5AA5C33C) {
620                 kprintf("dgb%d: 2nd memory test failed\n",dev->id_unit);
621                 sc->status=DISABLED;
622                 hidewin(sc);
623                 lwkt_reltoken(&tty_token);
624                 return 0;
625         }
626                 
627         addr=setinitwin(sc,BIOSCODE+((0xF000-sc->mem_seg)<<4));
628         *(u_long volatile *)(mem+addr) = 0x5AA5C33C;
629         if(*(u_long volatile *)(mem+addr)!=0x5AA5C33C) {
630                 kprintf("dgb%d: 3rd (BIOS) memory test failed\n",dev->id_unit);
631         }
632                 
633         addr=setinitwin(sc,MISCGLOBAL);
634         for(i=0; i<16; i++) {
635                 mem[addr+i]=0;
636         }
637
638         if(sc->type==PCXI || sc->type==PCXE) {
639
640                 addr=BIOSCODE+((0xF000-sc->mem_seg)<<4);
641
642                 DPRINT3(DB_INFO,"dgb%d: BIOS local address=0x%x\n",unit,addr);
643
644                 ptr= mem+addr;
645
646                 for(i=0; i<pcxx_nbios; i++, ptr++)
647                         *ptr = pcxx_bios[i];
648
649                 ptr= mem+addr;
650
651                 nfails=0;
652                 for(i=0; i<pcxx_nbios; i++, ptr++)
653                         if( *ptr != pcxx_bios[i] ) {
654                                 DPRINT5(DB_EXCEPT,"dgb%d: wrong code in BIOS at addr 0x%x : \
655 0x%x instead of 0x%x\n", unit, ptr-(mem+addr), *ptr, pcxx_bios[i] );
656
657                                 if(++nfails>=5) {
658                                         kprintf("dgb%d: 4th memory test (BIOS load) fails\n",unit);
659                                         break;
660                                         }
661                                 }
662
663                 outb(sc->port,FEPMEM);
664
665                 for(i=0; (inb(sc->port) & FEPMASK) != FEPMEM ; i++) {
666                         if(i>10000) {
667                                 kprintf("dgb%d: BIOS start failed\n",dev->id_unit);
668                                 sc->status=DISABLED;
669                                 hidewin(sc);
670                                 lwkt_reltoken(&tty_token);
671                                 return 0;
672                         }
673                         DELAY(1);
674                 }
675
676                 DPRINT3(DB_INFO,"dgb%d: reset dropped after %d us\n",unit,i);
677
678                 for(i=0; i<200000; i++) {
679                         if( *((ushort volatile *)(mem+MISCGLOBAL)) == *((ushort *)"GD") )
680                                 goto load_fep;
681                         DELAY(1);
682                 }
683                 kprintf("dgb%d: BIOS download failed\n",dev->id_unit);
684                 DPRINT4(DB_EXCEPT,"dgb%d: code=0x%x must be 0x%x\n",
685                         dev->id_unit,
686                         *((ushort volatile *)(mem+MISCGLOBAL)),
687                         *((ushort *)"GD"));
688
689                 sc->status=DISABLED;
690                 hidewin(sc);
691                 lwkt_reltoken(&tty_token);
692                 return 0;
693         }
694
695         if(sc->type==PCXEVE) {
696                 /* set window 7 */
697                 outb(sc->port+1,0xFF);
698
699                 ptr= mem+(BIOSCODE & 0x1FFF);
700
701                 for(i=0; i<pcxx_nbios; i++)
702                         *ptr++ = pcxx_bios[i];
703
704                 ptr= mem+(BIOSCODE & 0x1FFF);
705
706                 nfails=0;
707                 for(i=0; i<pcxx_nbios; i++, ptr++)
708                         if( *ptr != pcxx_bios[i] ) {
709                                 DPRINT5(DB_EXCEPT,"dgb%d: wrong code in BIOS at addr 0x%x : \
710 0x%x instead of 0x%x\n", unit, ptr-(mem+addr), *ptr, pcxx_bios[i] );
711
712                                 if(++nfails>=5) {
713                                         kprintf("dgb%d: 4th memory test (BIOS load) fails\n",unit);
714                                         break;
715                                         }
716                                 }
717
718                 outb(sc->port,FEPCLR);
719
720                 setwin(sc,0);
721
722                 for(i=0; (inb(sc->port) & FEPMASK) != FEPCLR ; i++) {
723                         if(i>10000) {
724                                 kprintf("dgb%d: BIOS start failed\n",dev->id_unit);
725                                 sc->status=DISABLED;
726                                 hidewin(sc);
727                                 lwkt_reltoken(&tty_token);
728                                 return 0;
729                         }
730                         DELAY(1);
731                 }
732
733                 DPRINT3(DB_INFO,"dgb%d: reset dropped after %d us\n",unit,i);
734
735                 addr=setwin(sc,MISCGLOBAL);
736
737                 for(i=0; i<200000; i++) {
738                         if(*(ushort volatile *)(mem+addr)== *(ushort *)"GD")
739                                 goto load_fep;
740                         DELAY(1);
741                 }
742                 kprintf("dgb%d: BIOS download failed\n",dev->id_unit);
743                 DPRINT5(DB_EXCEPT,"dgb%d: Error#(0x%x,0x%x) code=0x%x\n",
744                         dev->id_unit,
745                         *(ushort volatile *)(mem+0xC12),
746                         *(ushort volatile *)(mem+0xC14),
747                         *(ushort volatile *)(mem+MISCGLOBAL));
748
749                 sc->status=DISABLED;
750                 hidewin(sc);
751                 lwkt_reltoken(&tty_token);
752                 return 0;
753         }
754
755 load_fep:
756         DPRINT2(DB_INFO,"dgb%d: BIOS loaded\n",dev->id_unit);
757
758         addr=setwin(sc,FEPCODE);
759
760         ptr= mem+addr;
761
762         for(i=0; i<pcxx_ncook; i++)
763                 *ptr++ = pcxx_cook[i];
764
765         addr=setwin(sc,MBOX);
766         *(ushort volatile *)(mem+addr+ 0)=2;
767         *(ushort volatile *)(mem+addr+ 2)=sc->mem_seg+FEPCODESEG;
768         *(ushort volatile *)(mem+addr+ 4)=0;
769         *(ushort volatile *)(mem+addr+ 6)=FEPCODESEG;
770         *(ushort volatile *)(mem+addr+ 8)=0;
771         *(ushort volatile *)(mem+addr+10)=pcxx_ncook;
772
773         outb(sc->port,FEPMEM|FEPINT); /* send interrupt to BIOS */
774         outb(sc->port,FEPMEM);
775
776         for(i=0; *(ushort volatile *)(mem+addr)!=0; i++) {
777                 if(i>200000) {
778                         kprintf("dgb%d: FEP code download failed\n",unit);
779                         DPRINT3(DB_EXCEPT,"dgb%d: code=0x%x must be 0\n", unit,
780                                 *(ushort volatile *)(mem+addr));
781                         sc->status=DISABLED;
782                         hidewin(sc);
783                         lwkt_reltoken(&tty_token);
784                         return 0;
785                 }
786         }
787
788         DPRINT2(DB_INFO,"dgb%d: FEP code loaded\n",unit);
789
790         *(ushort volatile *)(mem+setwin(sc,FEPSTAT))=0;
791         addr=setwin(sc,MBOX);
792         *(ushort volatile *)(mem+addr+0)=1;
793         *(ushort volatile *)(mem+addr+2)=FEPCODESEG;
794         *(ushort volatile *)(mem+addr+4)=0x4;
795
796         outb(sc->port,FEPINT); /* send interrupt to BIOS */
797         outb(sc->port,FEPCLR);
798
799         addr=setwin(sc,FEPSTAT);
800         for(i=0; *(ushort volatile *)(mem+addr)!= *(ushort *)"OS"; i++) {
801                 if(i>200000) {
802                         kprintf("dgb%d: FEP/OS start failed\n",dev->id_unit);
803                         sc->status=DISABLED;
804                         hidewin(sc);
805                         lwkt_reltoken(&tty_token);
806                         return 0;
807                 }
808         }
809
810         DPRINT2(DB_INFO,"dgb%d: FEP/OS started\n",dev->id_unit);
811
812         sc->numports= *(ushort volatile *)(mem+setwin(sc,NPORT));
813
814         kprintf("dgb%d: %d ports\n",unit,sc->numports);
815
816         if(sc->numports > MAX_DGB_PORTS) {
817                 kprintf("dgb%d: too many ports\n",unit);
818                 sc->status=DISABLED;
819                 hidewin(sc);
820                 lwkt_reltoken(&tty_token);
821                 return 0;
822         }
823
824         if(nports+sc->numports>NDGBPORTS) {
825                 kprintf("dgb%d: only %d ports are usable\n", unit, NDGBPORTS-nports);
826                 sc->numports=NDGBPORTS-nports;
827         }
828
829         /* allocate port and tty structures */
830         sc->ports=&dgb_ports[nports];
831         sc->ttys=&dgb_tty[nports];
832         nports+=sc->numports;
833
834         addr=setwin(sc,PORTBASE);
835         pstat=(const ushort volatile *)(mem+addr);
836
837         for(i=0; i<sc->numports && pstat[i]; i++)
838                 if(pstat[i])
839                         sc->ports[i].status=ENABLED;
840                 else {
841                         sc->ports[i].status=DISABLED;
842                         kprintf("dgb%d: port%d is broken\n", unit, i);
843                 }
844
845         /* We should now init per-port structures */
846         bc=(volatile struct board_chan *)(mem + CHANSTRUCT);
847         sc->mailbox=(volatile struct global_data *)(mem + FEP_GLOBAL);
848
849         if(sc->numports<3)
850                 shrinkmem=1;
851         else
852                 shrinkmem=0;
853
854         for(i=0; i<sc->numports; i++, bc++) {
855                 port= &sc->ports[i];
856
857                 port->tty=&sc->ttys[i];
858                 port->unit=unit;
859
860                 port->brdchan=bc;
861
862                 if(sc->altpin) {
863                         port->dsr=CD;
864                         port->dcd=DSR;
865                 } else {
866                         port->dcd=CD;
867                         port->dsr=DSR;
868                 }
869
870                 port->pnum=i;
871
872                 if(shrinkmem) {
873                         DPRINT2(DB_INFO,"dgb%d: shrinking memory\n",unit);
874                         fepcmd(port, SETBUFFER, 32, 0, 0, 0);
875                         shrinkmem=0;
876                         }
877
878                 if(sc->type!=PCXEVE) {
879                         port->txptr=mem+((bc->tseg-sc->mem_seg)<<4);
880                         port->rxptr=mem+((bc->rseg-sc->mem_seg)<<4);
881                         port->txwin=port->rxwin=0;
882                 } else {
883                         port->txptr=mem+( ((bc->tseg-sc->mem_seg)<<4) & 0x1FFF );
884                         port->rxptr=mem+( ((bc->rseg-sc->mem_seg)<<4) & 0x1FFF );
885                         port->txwin=FEPWIN | ((bc->tseg-sc->mem_seg)>>9);
886                         port->rxwin=FEPWIN | ((bc->rseg-sc->mem_seg)>>9);
887                 }
888
889                 port->txbufhead=0;
890                 port->rxbufhead=0;
891                 port->txbufsize=bc->tmax+1;
892                 port->rxbufsize=bc->rmax+1;
893
894                 lowwater= (port->txbufsize>=2000) ? 1024 : (port->txbufsize/2);
895                 setwin(sc,0);
896                 fepcmd(port, STXLWATER, lowwater, 0, 10, 0);
897                 fepcmd(port, SRXLWATER, port->rxbufsize/4, 0, 10, 0);
898                 fepcmd(port, SRXHWATER, 3*port->rxbufsize/4, 0, 10, 0);
899
900                 bc->edelay=100;
901                 bc->idata=1;
902
903                 port->startc=bc->startc;
904                 port->startca=bc->startca;
905                 port->stopc=bc->stopc;
906                 port->stopca=bc->stopca;
907                         
908                 /*port->close_delay=50;*/
909                 port->close_delay=3 * hz;
910                 port->do_timestamp=0;
911                 port->do_dcd_timestamp=0;
912
913                 /*
914                  * We don't use all the flags from <sys/ttydefaults.h> since they
915                  * are only relevant for logins.  It's important to have echo off
916                  * initially so that the line doesn't start blathering before the
917                  * echo flag can be turned off.
918                  */
919                 port->it_in.c_iflag = TTYDEF_IFLAG;
920                 port->it_in.c_oflag = TTYDEF_OFLAG;
921                 port->it_in.c_cflag = TTYDEF_CFLAG;
922                 port->it_in.c_lflag = TTYDEF_LFLAG;
923                 termioschars(&port->it_in);
924                 port->it_in.c_ispeed = port->it_in.c_ospeed = dgbdefaultrate;
925                 port->it_out = port->it_in;
926                 /* MAX_DGB_PORTS is 32 => [0-9a-v] */
927                 suffix = i < 10 ? '0' + i : 'a' + i - 10;
928                 cdevsw_add(&dgb_cdevsw, 0xffff0000, unit << 16);
929                 make_dev(&dgb_cdevsw, (unit<<16)+i,
930                     UID_ROOT, GID_WHEEL, 0600, "ttyD%d%c", unit, suffix);
931
932                 make_dev(&dgb_cdevsw, (unit<<16)+i+32,
933                     UID_ROOT, GID_WHEEL, 0600, "ttyiD%d%c", unit, suffix);
934
935                 make_dev(&dgb_cdevsw, (unit<<16)+i+64,
936                     UID_ROOT, GID_WHEEL, 0600, "ttylD%d%c", unit, suffix);
937
938                 make_dev(&dgb_cdevsw, (unit<<16)+i+128,
939                     UID_UUCP, GID_DIALER, 0660, "cuaD%d%c", unit, suffix);
940
941                 make_dev(&dgb_cdevsw, (unit<<16)+i+160,
942                     UID_UUCP, GID_DIALER, 0660, "cuaiD%d%c", unit, suffix);
943
944                 make_dev(&dgb_cdevsw, (unit<<16)+i+192,
945                     UID_UUCP, GID_DIALER, 0660, "cualD%d%c", unit, suffix);
946         }
947
948         hidewin(sc);
949
950         /* register the polling function */
951         callout_reset(&sc->dgbpoll, hz / POLLSPERSEC, dgbpoll, (void *)unit);
952
953         lwkt_reltoken(&tty_token);
954         return 1;
955 }
956
957 /* ARGSUSED */
958 static  int
959 dgbopen(cdev_t dev, int flag, int mode, struct thread *td)
960 {
961         struct dgb_softc *sc;
962         struct tty *tp;
963         int unit;
964         int mynor;
965         int pnum;
966         struct dgb_p *port;
967         int error;
968         volatile struct board_chan *bc;
969
970         error=0;
971
972         lwkt_gettoken(&tty_token);
973         mynor=minor(dev);
974         unit=MINOR_TO_UNIT(mynor);
975         pnum=MINOR_TO_PORT(mynor);
976
977         if(unit >= NDGB) {
978                 DPRINT2(DB_EXCEPT,"dgb%d: try to open a nonexisting card\n",unit);
979                 lwkt_reltoken(&tty_token);
980                 return ENXIO;
981         }
982
983         sc=&dgb_softc[unit];
984
985         if(sc->status!=ENABLED) {
986                 DPRINT2(DB_EXCEPT,"dgb%d: try to open a disabled card\n",unit);
987                 lwkt_reltoken(&tty_token);
988                 return ENXIO;
989         }
990
991         if(pnum>=sc->numports) {
992                 DPRINT3(DB_EXCEPT,"dgb%d: try to open non-existing port %d\n",unit,pnum);
993                 lwkt_reltoken(&tty_token);
994                 return ENXIO;
995         }
996
997         if(mynor & CONTROL_MASK) {
998                 lwkt_reltoken(&tty_token);
999                 return 0;
1000         }
1001
1002         tp=&sc->ttys[pnum];
1003         dev->si_tty = tp;
1004         port=&sc->ports[pnum];
1005         bc=port->brdchan;
1006
1007 open_top:
1008         
1009         crit_enter();
1010
1011         while(port->closing) {
1012                 error=tsleep(&port->closing, PCATCH, "dgocl", 0);
1013
1014                 if(error) {
1015                         DPRINT4(DB_OPEN,"dgb%d: port%d: tsleep(dgocl) error=%d\n",unit,pnum,error);
1016                         goto out;
1017                 }
1018         }
1019
1020         if (tp->t_state & TS_ISOPEN) {
1021                 /*
1022                  * The device is open, so everything has been initialized.
1023                  * Handle conflicts.
1024                  */
1025                 if (mynor & CALLOUT_MASK) {
1026                         if (!port->active_out) {
1027                                 error = EBUSY;
1028                                 DPRINT4(DB_OPEN,"dgb%d: port%d: BUSY error=%d\n",unit,pnum,error);
1029                                 goto out;
1030                         }
1031                 } else {
1032                         if (port->active_out) {
1033                                 if (flag & O_NONBLOCK) {
1034                                         error = EBUSY;
1035                                         DPRINT4(DB_OPEN,"dgb%d: port%d: BUSY error=%d\n",unit,pnum,error);
1036                                         goto out;
1037                                 }
1038                                 error = tsleep(&port->active_out,
1039                                                PCATCH, "dgbi", 0);
1040                                 if (error != 0) {
1041                                         DPRINT4(DB_OPEN,"dgb%d: port%d: tsleep(dgbi) error=%d\n",
1042                                                 unit,pnum,error);
1043                                         goto out;
1044                                 }
1045                                 crit_exit();
1046                                 goto open_top;
1047                         }
1048                 }
1049                 if (tp->t_state & TS_XCLUDE && priv_check(td, PRIV_ROOT)) {
1050                         error = EBUSY;
1051                         goto out;
1052                 }
1053         } else {
1054                 /*
1055                  * The device isn't open, so there are no conflicts.
1056                  * Initialize it.  Initialization is done twice in many
1057                  * cases: to preempt sleeping callin opens if we are
1058                  * callout, and to complete a callin open after DCD rises.
1059                  */
1060                 tp->t_oproc=dgbstart;
1061                 tp->t_param=dgbparam;
1062                 tp->t_stop=dgbstop;
1063                 tp->t_dev=dev;
1064                 tp->t_termios= (mynor & CALLOUT_MASK) ?
1065                                                         port->it_out :
1066                                                         port->it_in;
1067
1068                 crit_enter();
1069                 setwin(sc,0);
1070                 port->imodem=bc->mstat;
1071                 bc->rout=bc->rin; /* clear input queue */
1072                 bc->idata=1;
1073 #ifdef PRINT_BUFSIZE
1074                 kprintf("dgb buffers tx=%x:%x rx=%x:%x\n",bc->tseg,bc->tmax,bc->rseg,bc->rmax);
1075 #endif
1076
1077                 hidewin(sc);
1078                 crit_exit();
1079
1080                 port->wopeners++;
1081                 error=dgbparam(tp, &tp->t_termios);
1082                 port->wopeners--;
1083
1084                 if(error!=0) {
1085                         DPRINT4(DB_OPEN,"dgb%d: port%d: dgbparam error=%d\n",unit,pnum,error);
1086                         goto out;
1087                 }
1088
1089                 /* handle fake DCD for callout devices */
1090                 /* and initial DCD */
1091
1092                 if( (port->imodem & port->dcd) || mynor & CALLOUT_MASK )
1093                         linesw[tp->t_line].l_modem(tp,1);
1094
1095         }
1096
1097         /*
1098          * Wait for DCD if necessary.
1099          */
1100         if (!(tp->t_state & TS_CARR_ON) && !(mynor & CALLOUT_MASK)
1101             && !(tp->t_cflag & CLOCAL) && !(flag & O_NONBLOCK)) {
1102                 ++port->wopeners;
1103                 error = tsleep(TSA_CARR_ON(tp), PCATCH, "dgdcd", 0);
1104                 --port->wopeners;
1105                 if (error != 0) {
1106                         DPRINT4(DB_OPEN,"dgb%d: port%d: tsleep(dgdcd) error=%d\n",unit,pnum,error);
1107                         goto out;
1108                 }
1109                 crit_exit();
1110                 goto open_top;
1111         }
1112         error = linesw[tp->t_line].l_open(dev, tp);
1113         disc_optim(tp,&tp->t_termios);
1114         DPRINT4(DB_OPEN,"dgb%d: port%d: l_open error=%d\n",unit,pnum,error);
1115
1116         if (tp->t_state & TS_ISOPEN && mynor & CALLOUT_MASK)
1117                 port->active_out = TRUE;
1118
1119         port->used=1;
1120
1121         /* If any port is open (i.e. the open() call is completed for it) 
1122          * the device is busy
1123          */
1124
1125 out:
1126         disc_optim(tp,&tp->t_termios);
1127         crit_exit();
1128
1129         if( !(tp->t_state & TS_ISOPEN) && port->wopeners==0 )
1130                 dgbhardclose(port);
1131
1132         DPRINT4(DB_OPEN,"dgb%d: port%d: open() returns %d\n",unit,pnum,error);
1133
1134         lwkt_reltoken(&tty_token);
1135         return error;
1136 }
1137
1138 /*ARGSUSED*/
1139 static  int
1140 dgbclose(cdev_t dev, int flag, int mode, struct thread *td)
1141 {
1142         struct tty *tp;
1143         int unit, pnum;
1144         struct dgb_softc *sc;
1145         struct dgb_p *port;
1146         int mynor;
1147         int i;
1148
1149         mynor=minor(dev);
1150         if(mynor & CONTROL_MASK)
1151                 return 0;
1152         lwkt_gettoken(&tty_token);
1153         unit=MINOR_TO_UNIT(mynor);
1154         pnum=MINOR_TO_PORT(mynor);
1155
1156         sc=&dgb_softc[unit];
1157         tp=&sc->ttys[pnum];
1158         port=sc->ports+pnum;
1159
1160         DPRINT3(DB_CLOSE,"dgb%d: port%d: closing\n",unit,pnum);
1161
1162         DPRINT3(DB_CLOSE,"dgb%d: port%d: draining port\n",unit,pnum);
1163         dgb_drain_or_flush(port);
1164
1165         crit_enter();
1166
1167         port->closing=1;
1168         DPRINT3(DB_CLOSE,"dgb%d: port%d: closing line disc\n",unit,pnum);
1169         linesw[tp->t_line].l_close(tp,flag);
1170         disc_optim(tp,&tp->t_termios);
1171
1172         DPRINT3(DB_CLOSE,"dgb%d: port%d: hard closing\n",unit,pnum);
1173         dgbhardclose(port);
1174         DPRINT3(DB_CLOSE,"dgb%d: port%d: closing tty\n",unit,pnum);
1175         ttyclose(tp);
1176         port->closing=0;
1177         wakeup(&port->closing);
1178         port->used=0;
1179
1180         /* mark the card idle when all ports are closed */
1181
1182         for(i=0; i<sc->numports; i++)
1183                 if(sc->ports[i].used)
1184                         break;
1185
1186         crit_exit();
1187
1188         DPRINT3(DB_CLOSE,"dgb%d: port%d: closed\n",unit,pnum);
1189
1190         wakeup(TSA_CARR_ON(tp));
1191         wakeup(&port->active_out);
1192         port->active_out=0;
1193
1194         DPRINT3(DB_CLOSE,"dgb%d: port%d: close exit\n",unit,pnum);
1195
1196         lwkt_reltoken(&tty_token);
1197         return 0;
1198 }
1199
1200 /*
1201  * NOTE: Must be called with tty_token held
1202  */
1203 static void
1204 dgbhardclose(port)
1205         struct dgb_p *port;
1206 {
1207         struct dgb_softc *sc=&dgb_softc[port->unit];
1208         volatile struct board_chan *bc=port->brdchan;
1209
1210         ASSERT_LWKT_TOKEN_HELD(&tty_token);
1211
1212         crit_enter();
1213         port->do_timestamp = 0;
1214         setwin(sc,0);
1215
1216         bc->idata=0; bc->iempty=0; bc->ilow=0;
1217         if(port->tty->t_cflag & HUPCL) {
1218                 port->omodem &= ~(RTS|DTR);
1219                 fepcmd(port, SETMODEM, 0, DTR|RTS, 0, 1);
1220         }
1221
1222         hidewin(sc);
1223         crit_exit();
1224
1225         callout_reset(&sc->dgb_pause, hz / 2, dgb_pause, &port->brdchan);
1226         tsleep(&port->brdchan, PCATCH, "dgclo", 0);
1227 }
1228
1229 static void 
1230 dgb_pause(chan)
1231         void *chan;
1232 {
1233         lwkt_gettoken(&tty_token);
1234         wakeup((caddr_t)chan);
1235         lwkt_reltoken(&tty_token);
1236 }
1237
1238 static void
1239 dgbpoll(unit_c)
1240         void *unit_c;
1241 {
1242         int unit=(int)unit_c;
1243         int pnum;
1244         struct dgb_p *port;
1245         struct dgb_softc *sc=&dgb_softc[unit];
1246         int head, tail;
1247         u_char *eventbuf;
1248         int event, mstat, lstat;
1249         volatile struct board_chan *bc;
1250         struct tty *tp;
1251         int rhead, rtail;
1252         int whead, wtail;
1253         int size;
1254         u_char *ptr;
1255         int ocount;
1256         int ibuf_full,obuf_full;
1257
1258         lwkt_gettoken(&tty_token);
1259         BoardMemWinState ws=bmws_get();
1260
1261         if(sc->status==DISABLED) {
1262                 kprintf("dgb%d: polling of disabled board stopped\n",unit);
1263                 lwkt_reltoken(&tty_token);
1264                 return;
1265         }
1266         
1267         setwin(sc,0);
1268
1269         head=sc->mailbox->ein;
1270         tail=sc->mailbox->eout;
1271
1272         while(head!=tail) {
1273                 if(head >= FEP_IMAX-FEP_ISTART 
1274                 || tail >= FEP_IMAX-FEP_ISTART 
1275                 || (head|tail) & 03 ) {
1276                         kprintf("dgb%d: event queue's head or tail is wrong! hd=%d,tl=%d\n", unit,head,tail);
1277                         break;
1278                 }
1279
1280                 eventbuf=sc->vmem+tail+FEP_ISTART;
1281                 pnum=eventbuf[0];
1282                 event=eventbuf[1];
1283                 mstat=eventbuf[2];
1284                 lstat=eventbuf[3];
1285
1286                 port=&sc->ports[pnum];
1287                 bc=port->brdchan;
1288                 tp=&sc->ttys[pnum];
1289
1290                 if(pnum>=sc->numports || port->status==DISABLED) {
1291                         kprintf("dgb%d: port%d: got event on nonexisting port\n",unit,pnum);
1292                 } else if(port->used || port->wopeners>0 ) {
1293
1294                         int wrapmask=port->rxbufsize-1;
1295
1296                         if( !(event & ALL_IND) ) 
1297                                 kprintf("dgb%d: port%d: ? event 0x%x mstat 0x%x lstat 0x%x\n",
1298                                         unit, pnum, event, mstat, lstat);
1299
1300                         if(event & DATA_IND) {
1301                                 DPRINT3(DB_DATA,"dgb%d: port%d: DATA_IND\n",unit,pnum);
1302
1303                                 rhead=bc->rin & wrapmask; 
1304                                 rtail=bc->rout & wrapmask;
1305
1306                                 if( !(tp->t_cflag & CREAD) || !port->used ) {
1307                                         bc->rout=rhead;
1308                                         goto end_of_data;
1309                                 }
1310
1311                                 if(bc->orun) {
1312                                         kprintf("dgb%d: port%d: overrun\n", unit, pnum);
1313                                         bc->orun=0;
1314                                 }
1315
1316                                 if(!(tp->t_state & TS_ISOPEN))
1317                                         goto end_of_data;
1318
1319                                 for(ibuf_full=FALSE;rhead!=rtail && !ibuf_full;) {
1320                                         DPRINT5(DB_RXDATA,"dgb%d: port%d: p rx head=%d tail=%d\n",
1321                                                 unit,pnum,rhead,rtail);
1322
1323                                         if(rhead>rtail)
1324                                                 size=rhead-rtail;
1325                                         else
1326                                                 size=port->rxbufsize-rtail;
1327
1328                                         ptr=__DEVOLATILE(u_char *, port->rxptr+rtail);
1329
1330 /* Helg: */
1331                                         if( tp->t_rawq.c_cc + size > DGB_IBUFSIZE ) {
1332                                                 size=DGB_IBUFSIZE-tp->t_rawq.c_cc;
1333                                                 DPRINT1(DB_RXDATA,"*");
1334                                                 ibuf_full=TRUE;
1335                                         }
1336
1337                                         if(size) {
1338                                                 if (tp->t_state & TS_CAN_BYPASS_L_RINT) {
1339                                                         DPRINT1(DB_RXDATA,"!");
1340                                                         towin(sc,port->rxwin);
1341                                                         tk_nin += size;
1342                                                         tk_rawcc += size;
1343                                                         tp->t_rawcc += size;
1344                                                         b_to_q(ptr,size,&tp->t_rawq);
1345                                                         setwin(sc,0);
1346                                                 } else {
1347                                                         int i=size;
1348                                                         unsigned char chr;
1349                                                         do {
1350                                                                 towin(sc,port->rxwin);
1351                                                                 chr= *ptr++;
1352                                                                 hidewin(sc);
1353                                                                (*linesw[tp->t_line].l_rint)(chr, tp);
1354                                                         } while (--i > 0 );
1355                                                         setwin(sc,0);
1356                                                 }
1357                                         }
1358                                         rtail= (rtail + size) & wrapmask;
1359                                         bc->rout=rtail;
1360                                         rhead=bc->rin & wrapmask;
1361                                         hidewin(sc);
1362                                         ttwakeup(tp);
1363                                         setwin(sc,0);
1364                                 }
1365                         end_of_data: ;
1366                         }
1367
1368                         if(event & MODEMCHG_IND) {
1369                                 DPRINT3(DB_MODEM,"dgb%d: port%d: MODEMCHG_IND\n",unit,pnum);
1370                                 port->imodem=mstat;
1371                                 if(mstat & port->dcd) {
1372                                         hidewin(sc);
1373                                         linesw[tp->t_line].l_modem(tp,1);
1374                                         setwin(sc,0);
1375                                         wakeup(TSA_CARR_ON(tp));
1376                                 } else {
1377                                         hidewin(sc);
1378                                         linesw[tp->t_line].l_modem(tp,0);
1379                                         setwin(sc,0);
1380                                         if( port->draining) {
1381                                                 port->draining=0;
1382                                                 wakeup(&port->draining);
1383                                         }
1384                                 }
1385                         }
1386
1387                         if(event & BREAK_IND) {
1388                                 if((tp->t_state & TS_ISOPEN) && (tp->t_iflag & IGNBRK)) {
1389                                         DPRINT3(DB_BREAK,"dgb%d: port%d: BREAK_IND\n",unit,pnum);
1390                                         hidewin(sc);
1391                                         linesw[tp->t_line].l_rint(TTY_BI, tp);
1392                                         setwin(sc,0);
1393                                 }
1394                         }
1395
1396 /* Helg: with output flow control */
1397
1398                         if(event & (LOWTX_IND | EMPTYTX_IND) ) {
1399                                 DPRINT3(DB_TXDATA,"dgb%d: port%d: LOWTX_IND or EMPTYTX_IND\n",unit,pnum);
1400
1401                                 if( (event & EMPTYTX_IND ) && tp->t_outq.c_cc==0
1402                                 && port->draining) {
1403                                         port->draining=0;
1404                                         wakeup(&port->draining);
1405                                         bc->ilow=0; bc->iempty=0;
1406                                 } else {
1407
1408                                         int wrapmask=port->txbufsize-1;
1409
1410                                         for(obuf_full=FALSE; tp->t_outq.c_cc!=0 && !obuf_full; ) {
1411                                                 /* add "last-minute" data to write buffer */
1412                                                 if(!(tp->t_state & TS_BUSY)) {
1413                                                         hidewin(sc);
1414 #ifndef TS_ASLEEP       /* post 2.0.5 FreeBSD */
1415                                                         ttwwakeup(tp);
1416 #else
1417                                                         if(tp->t_outq.c_cc <= tp->t_lowat) {
1418                                                                 if(tp->t_state & TS_ASLEEP) {
1419                                                                         tp->t_state &= ~TS_ASLEEP;
1420                                                                         wakeup(TSA_OLOWAT(tp));
1421                                                                 }
1422                                                                 /* selwakeup(&tp->t_wsel); */
1423                                                         }
1424 #endif
1425                                                         setwin(sc,0);
1426                                                 }
1427                                                 crit_enter();
1428
1429                                         whead=bc->tin & wrapmask;
1430                                         wtail=bc->tout & wrapmask;
1431
1432                                         if(whead<wtail)
1433                                                 size=wtail-whead-1;
1434                                         else {
1435                                                 size=port->txbufsize-whead;
1436                                                 if(wtail==0)
1437                                                         size--;
1438                                         }
1439
1440                                         if(size==0) {
1441                                                 DPRINT5(DB_WR,"dgb: head=%d tail=%d size=%d full=%d\n",
1442                                                         whead,wtail,size,obuf_full);
1443                                                 bc->iempty=1; bc->ilow=1;
1444                                                 obuf_full=TRUE;
1445                                                 crit_exit();
1446                                                 break;
1447                                         }
1448
1449                                         towin(sc,port->txwin);
1450
1451                                         ocount=q_to_b(&tp->t_outq, __DEVOLATILE(u_char *, port->txptr+whead), size);
1452                                         whead+=ocount;
1453
1454                                         setwin(sc,0);
1455                                         bc->tin=whead;
1456                                         bc->tin=whead & wrapmask;
1457                                         crit_exit();
1458                                 }
1459
1460                                 if(obuf_full) {
1461                                         DPRINT1(DB_WR," +BUSY\n");
1462                                         tp->t_state|=TS_BUSY;
1463                                 } else {
1464                                         DPRINT1(DB_WR," -BUSY\n");
1465                                         hidewin(sc);
1466 #ifndef TS_ASLEEP       /* post 2.0.5 FreeBSD */
1467                                         /* should clear TS_BUSY before ttwwakeup */
1468                                         if(tp->t_state & TS_BUSY)       {
1469                                                 tp->t_state &= ~TS_BUSY;
1470                                                 linesw[tp->t_line].l_start(tp);
1471                                                 ttwwakeup(tp);
1472                                         }
1473 #else
1474                                 if(tp->t_state & TS_ASLEEP) {
1475                                         tp->t_state &= ~TS_ASLEEP;
1476                                         wakeup(TSA_OLOWAT(tp));
1477                                 }
1478                                 tp->t_state &= ~TS_BUSY;
1479 #endif
1480                                         setwin(sc,0);
1481                                         }
1482                                 }
1483                         }
1484                         bc->idata=1;   /* require event on incoming data */ 
1485
1486                 } else {
1487                         bc=port->brdchan;
1488                         DPRINT4(DB_EXCEPT,"dgb%d: port%d: got event 0x%x on closed port\n",
1489                                 unit,pnum,event);
1490                         bc->rout=bc->rin;
1491                         bc->idata=bc->iempty=bc->ilow=0;
1492                 }
1493
1494                 tail= (tail+4) & (FEP_IMAX-FEP_ISTART-4);
1495         }
1496
1497         sc->mailbox->eout=tail;
1498         bmws_set(ws);
1499
1500         callout_reset(&sc->dgbpoll, hz / POLLSPERSEC, dgbpoll, unit_c);
1501         lwkt_reltoken(&tty_token);
1502 }
1503
1504 static  int
1505 dgbioctl(cdev_t dev, u_long cmd, caddr_t        data, int flag, struct thread *td)
1506 {
1507         struct dgb_softc *sc;
1508         int unit, pnum;
1509         struct dgb_p *port;
1510         int mynor;
1511         struct tty *tp;
1512         volatile struct board_chan *bc;
1513         int error;
1514         int tiocm_xxx;
1515
1516         lwkt_gettoken(&tty_token);
1517 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
1518         u_long          oldcmd;
1519         struct termios  term;
1520 #endif
1521
1522         BoardMemWinState ws=bmws_get();
1523
1524         mynor=minor(dev);
1525         unit=MINOR_TO_UNIT(mynor);
1526         pnum=MINOR_TO_PORT(mynor);
1527
1528         sc=&dgb_softc[unit];
1529         port=&sc->ports[pnum];
1530         tp=&sc->ttys[pnum];
1531         bc=port->brdchan;
1532
1533         if (mynor & CONTROL_MASK) {
1534                 struct termios *ct;
1535
1536                 switch (mynor & CONTROL_MASK) {
1537                 case CONTROL_INIT_STATE:
1538                         ct = mynor & CALLOUT_MASK ? &port->it_out : &port->it_in;
1539                         break;
1540                 case CONTROL_LOCK_STATE:
1541                         ct = mynor & CALLOUT_MASK ? &port->lt_out : &port->lt_in;
1542                         break;
1543                 default:
1544                         lwkt_reltoken(&tty_token);
1545                         return (ENODEV);        /* /dev/nodev */
1546                 }
1547                 switch (cmd) {
1548                 case TIOCSETA:
1549                         error = priv_check(td, PRIV_ROOT);
1550                         if (error != 0) {
1551                                 lwkt_reltoken(&tty_token);
1552                                 return (error);
1553                         }
1554                         *ct = *(struct termios *)data;
1555                         lwkt_reltoken(&tty_token);
1556                         return (0);
1557                 case TIOCGETA:
1558                         *(struct termios *)data = *ct;
1559                         lwkt_reltoken(&tty_token);
1560                         return (0);
1561                 case TIOCGETD:
1562                         *(int *)data = TTYDISC;
1563                         lwkt_reltoken(&tty_token);
1564                         return (0);
1565                 case TIOCGWINSZ:
1566                         bzero(data, sizeof(struct winsize));
1567                         lwkt_reltoken(&tty_token);
1568                         return (0);
1569                 default:
1570                         lwkt_reltoken(&tty_token);
1571                         return (ENOTTY);
1572                 }
1573         }
1574
1575 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
1576         term = tp->t_termios;
1577         if (cmd == TIOCSETA || cmd == TIOCSETAW || cmd == TIOCSETAF) {
1578           DPRINT6(DB_PARAM,"dgb%d: port%d: dgbioctl-ISNOW c=0x%x i=0x%x l=0x%x\n",unit,pnum,term.c_cflag,term.c_iflag,term.c_lflag);
1579         }
1580         oldcmd = cmd;
1581         error = ttsetcompat(tp, &cmd, data, &term);
1582         if (error != 0) {
1583                 lwkt_reltoken(&tty_token);
1584                 return (error);
1585         }
1586         if (cmd != oldcmd)
1587                 data = (caddr_t)&term;
1588 #endif
1589
1590         if (cmd == TIOCSETA || cmd == TIOCSETAW || cmd == TIOCSETAF) {
1591                 int     cc;
1592                 struct termios *dt = (struct termios *)data;
1593                 struct termios *lt = mynor & CALLOUT_MASK
1594                                      ? &port->lt_out : &port->lt_in;
1595
1596                 DPRINT6(DB_PARAM,"dgb%d: port%d: dgbioctl-TOSET c=0x%x i=0x%x l=0x%x\n",unit,pnum,dt->c_cflag,dt->c_iflag,dt->c_lflag);
1597                 dt->c_iflag = (tp->t_iflag & lt->c_iflag)
1598                               | (dt->c_iflag & ~lt->c_iflag);
1599                 dt->c_oflag = (tp->t_oflag & lt->c_oflag)
1600                               | (dt->c_oflag & ~lt->c_oflag);
1601                 dt->c_cflag = (tp->t_cflag & lt->c_cflag)
1602                               | (dt->c_cflag & ~lt->c_cflag);
1603                 dt->c_lflag = (tp->t_lflag & lt->c_lflag)
1604                               | (dt->c_lflag & ~lt->c_lflag);
1605                 for (cc = 0; cc < NCCS; ++cc)
1606                         if (lt->c_cc[cc] != 0)
1607                                 dt->c_cc[cc] = tp->t_cc[cc];
1608                 if (lt->c_ispeed != 0)
1609                         dt->c_ispeed = tp->t_ispeed;
1610                 if (lt->c_ospeed != 0)
1611                         dt->c_ospeed = tp->t_ospeed;
1612         }
1613
1614         if(cmd==TIOCSTOP) {
1615                 crit_enter();
1616                 setwin(sc,0);
1617                 fepcmd(port, PAUSETX, 0, 0, 0, 0);
1618                 bmws_set(ws);
1619                 crit_exit();
1620                 lwkt_reltoken(&tty_token);
1621                 return 0;
1622         } else if(cmd==TIOCSTART) {
1623                 crit_enter();
1624                 setwin(sc,0);
1625                 fepcmd(port, RESUMETX, 0, 0, 0, 0);
1626                 bmws_set(ws);
1627                 crit_exit();
1628                 lwkt_reltoken(&tty_token);
1629                 return 0;
1630         }
1631
1632         if(cmd==TIOCSETAW || cmd==TIOCSETAF)
1633                 port->mustdrain=1;
1634
1635         error = linesw[tp->t_line].l_ioctl(tp, cmd, data, flag, td);
1636         if (error != ENOIOCTL) {
1637                 lwkt_reltoken(&tty_token);
1638                 return error;
1639         }
1640         crit_enter();
1641         error = ttioctl(tp, cmd, data, flag);
1642         disc_optim(tp,&tp->t_termios);
1643         port->mustdrain=0;
1644         if (error != ENOIOCTL) {
1645                 crit_exit();
1646                 if (cmd == TIOCSETA || cmd == TIOCSETAW || cmd == TIOCSETAF) {
1647                         DPRINT6(DB_PARAM,"dgb%d: port%d: dgbioctl-RES c=0x%x i=0x%x l=0x%x\n",unit,pnum,tp->t_cflag,tp->t_iflag,tp->t_lflag);
1648                 }
1649                 lwkt_reltoken(&tty_token);
1650                 return error;
1651         }
1652
1653         switch (cmd) {
1654         case TIOCSBRK:
1655 /* Helg: commented */
1656 /*              error=dgbdrain(port);*/
1657
1658                 if(error!=0) {
1659                         crit_exit();
1660                         lwkt_reltoken(&tty_token);
1661                         return error;
1662                 }
1663
1664                 crit_enter();
1665                 setwin(sc,0);
1666         
1667                 /* now it sends 250 millisecond break because I don't know */
1668                 /* how to send an infinite break */
1669
1670                 fepcmd(port, SENDBREAK, 250, 0, 10, 0);
1671                 hidewin(sc);
1672                 crit_exit();
1673                 break;
1674         case TIOCCBRK:
1675                 /* now it's empty */
1676                 break;
1677         case TIOCSDTR:
1678                 DPRINT3(DB_MODEM,"dgb%d: port%d: set DTR\n",unit,pnum);
1679                 port->omodem |= DTR;
1680                 crit_enter();
1681                 setwin(sc,0);
1682                 fepcmd(port, SETMODEM, port->omodem, RTS, 0, 1);
1683
1684                 if( !(bc->mstat & DTR) ) {
1685                         DPRINT3(DB_MODEM,"dgb%d: port%d: DTR is off\n",unit,pnum);
1686                 }
1687
1688                 hidewin(sc);
1689                 crit_exit();
1690                 break;
1691         case TIOCCDTR:
1692                 DPRINT3(DB_MODEM,"dgb%d: port%d: reset DTR\n",unit,pnum);
1693                 port->omodem &= ~DTR;
1694                 crit_enter();
1695                 setwin(sc,0);
1696                 fepcmd(port, SETMODEM, port->omodem, RTS|DTR, 0, 1);
1697
1698                 if( bc->mstat & DTR ) {
1699                         DPRINT3(DB_MODEM,"dgb%d: port%d: DTR is on\n",unit,pnum);
1700                 }
1701
1702                 hidewin(sc);
1703                 crit_exit();
1704                 break;
1705         case TIOCMSET:
1706                 if(*(int *)data & TIOCM_DTR)
1707                         port->omodem |=DTR;
1708                 else
1709                         port->omodem &=~DTR;
1710
1711                 if(*(int *)data & TIOCM_RTS)
1712                         port->omodem |=RTS;
1713                 else
1714                         port->omodem &=~RTS;
1715
1716                 crit_enter();
1717                 setwin(sc,0);
1718                 fepcmd(port, SETMODEM, port->omodem, RTS|DTR, 0, 1);
1719                 hidewin(sc);
1720                 crit_exit();
1721                 break;
1722         case TIOCMBIS:
1723                 if(*(int *)data & TIOCM_DTR)
1724                         port->omodem |=DTR;
1725
1726                 if(*(int *)data & TIOCM_RTS)
1727                         port->omodem |=RTS;
1728
1729                 crit_enter();
1730                 setwin(sc,0);
1731                 fepcmd(port, SETMODEM, port->omodem, RTS|DTR, 0, 1);
1732                 hidewin(sc);
1733                 crit_exit();
1734                 break;
1735         case TIOCMBIC:
1736                 if(*(int *)data & TIOCM_DTR)
1737                         port->omodem &=~DTR;
1738
1739                 if(*(int *)data & TIOCM_RTS)
1740                         port->omodem &=~RTS;
1741
1742                 crit_enter();
1743                 setwin(sc,0);
1744                 fepcmd(port, SETMODEM, port->omodem, RTS|DTR, 0, 1);
1745                 hidewin(sc);
1746                 crit_exit();
1747                 break;
1748         case TIOCMGET:
1749                 setwin(sc,0);
1750                 port->imodem=bc->mstat;
1751                 hidewin(sc);
1752
1753                 tiocm_xxx = TIOCM_LE;   /* XXX - always enabled while open */
1754
1755                 DPRINT3(DB_MODEM,"dgb%d: port%d: modem stat -- ",unit,pnum);
1756
1757                 if (port->imodem & DTR) {
1758                         DPRINT1(DB_MODEM,"DTR ");
1759                         tiocm_xxx |= TIOCM_DTR;
1760                 }
1761                 if (port->imodem & RTS) {
1762                         DPRINT1(DB_MODEM,"RTS ");
1763                         tiocm_xxx |= TIOCM_RTS;
1764                 }
1765                 if (port->imodem & CTS) {
1766                         DPRINT1(DB_MODEM,"CTS ");
1767                         tiocm_xxx |= TIOCM_CTS;
1768                 }
1769                 if (port->imodem & port->dcd) {
1770                         DPRINT1(DB_MODEM,"DCD ");
1771                         tiocm_xxx |= TIOCM_CD;
1772                 }
1773                 if (port->imodem & port->dsr) {
1774                         DPRINT1(DB_MODEM,"DSR ");
1775                         tiocm_xxx |= TIOCM_DSR;
1776                 }
1777                 if (port->imodem & RI) {
1778                         DPRINT1(DB_MODEM,"RI ");
1779                         tiocm_xxx |= TIOCM_RI;
1780                 }
1781                 *(int *)data = tiocm_xxx;
1782                 DPRINT1(DB_MODEM,"--\n");
1783                 break;
1784         case TIOCMSDTRWAIT:
1785                 /* must be root since the wait applies to following logins */
1786                 error = priv_check(td, PRIV_ROOT);
1787                 if (error != 0) {
1788                         crit_exit();
1789                         lwkt_reltoken(&tty_token);
1790                         return (error);
1791                 }
1792                 port->close_delay = *(int *)data * hz / 100;
1793                 break;
1794         case TIOCMGDTRWAIT:
1795                 *(int *)data = port->close_delay * 100 / hz;
1796                 break;
1797         case TIOCTIMESTAMP:
1798                 port->do_timestamp = TRUE;
1799                 *(struct timeval *)data = port->timestamp;
1800                 break;
1801         case TIOCDCDTIMESTAMP:
1802                 port->do_dcd_timestamp = TRUE;
1803                 *(struct timeval *)data = port->dcd_timestamp;
1804                 break;
1805         default:
1806                 bmws_set(ws);
1807                 crit_exit();
1808                 lwkt_reltoken(&tty_token);
1809                 return ENOTTY;
1810         }
1811         bmws_set(ws);
1812         crit_exit();
1813
1814         lwkt_reltoken(&tty_token);
1815         return 0;
1816 }
1817
1818 static void 
1819 wakeflush(p)
1820         void *p;
1821 {
1822         struct dgb_p *port=p;
1823
1824         lwkt_gettoken(&tty_token);
1825         wakeup(&port->draining);
1826         lwkt_reltoken(&tty_token);
1827 }
1828
1829 /* wait for the output to drain */
1830 /*
1831  * NOTE: Must be called with tty_token held
1832  */
1833 static int
1834 dgbdrain(port)
1835         struct dgb_p    *port;
1836 {
1837         struct dgb_softc *sc=&dgb_softc[port->unit];
1838         volatile struct board_chan *bc=port->brdchan;
1839         int error;
1840         int head, tail;
1841
1842         ASSERT_LWKT_TOKEN_HELD(&tty_token);
1843         BoardMemWinState ws=bmws_get();
1844
1845         setwin(sc,0);
1846
1847         bc->iempty=1;
1848         tail=bc->tout;
1849         head=bc->tin;
1850
1851         while(tail!=head) {
1852                 DPRINT5(DB_WR,"dgb%d: port%d: drain: head=%d tail=%d\n",
1853                         port->unit, port->pnum, head, tail);
1854
1855                 hidewin(sc);
1856                 port->draining=1;
1857                 callout_reset(&sc->wakeflush, hz, wakeflush,port);
1858                 error=tsleep(&port->draining, PCATCH, "dgdrn", 0);
1859                 port->draining=0;
1860                 setwin(sc,0);
1861
1862                 if (error != 0) {
1863                         DPRINT4(DB_WR,"dgb%d: port%d: tsleep(dgdrn) error=%d\n",
1864                                 port->unit,port->pnum,error);
1865
1866                         bc->iempty=0;
1867                         bmws_set(ws);
1868                         return error;
1869                 }
1870
1871                 tail=bc->tout;
1872                 head=bc->tin;
1873         }
1874         DPRINT5(DB_WR,"dgb%d: port%d: drain: head=%d tail=%d\n",
1875                 port->unit, port->pnum, head, tail);
1876         bmws_set(ws);
1877         return 0;
1878 }
1879
1880 /* wait for the output to drain */
1881 /* or simply clear the buffer it it's stopped */
1882 /*
1883  * NOTE: Must be called with tty_token held
1884  */
1885 static void
1886 dgb_drain_or_flush(port)
1887         struct dgb_p    *port;
1888 {
1889         struct tty *tp=port->tty;
1890         struct dgb_softc *sc=&dgb_softc[port->unit];
1891         volatile struct board_chan *bc=port->brdchan;
1892         int error;
1893         int lasttail;
1894         int head, tail;
1895
1896         ASSERT_LWKT_TOKEN_HELD(&tty_token);
1897         setwin(sc,0);
1898
1899         lasttail=-1;
1900         bc->iempty=1;
1901         tail=bc->tout;
1902         head=bc->tin;
1903
1904         while(tail!=head /* && tail!=lasttail */ ) {
1905                 DPRINT5(DB_WR,"dgb%d: port%d: flush: head=%d tail=%d\n",
1906                         port->unit, port->pnum, head, tail);
1907
1908                 /* if there is no carrier simply clean the buffer */
1909                 if( !(tp->t_state & TS_CARR_ON) ) {
1910                         bc->tout=bc->tin=0;
1911                         bc->iempty=0;
1912                         hidewin(sc);
1913                         return;
1914                 }
1915
1916                 hidewin(sc);
1917                 port->draining=1;
1918                 callout_reset(&sc->wakeflush, hz, wakeflush, port);
1919                 error=tsleep(&port->draining, PCATCH, "dgfls", 0);
1920                 port->draining=0;
1921                 setwin(sc,0);
1922
1923                 if (error != 0) {
1924                         DPRINT4(DB_WR,"dgb%d: port%d: tsleep(dgfls) error=%d\n",
1925                                 port->unit,port->pnum,error);
1926
1927                         /* silently clean the buffer */
1928
1929                         bc->tout=bc->tin=0;
1930                         bc->iempty=0;
1931                         hidewin(sc);
1932                         return;
1933                 }
1934
1935                 lasttail=tail;
1936                 tail=bc->tout;
1937                 head=bc->tin;
1938         }
1939         hidewin(sc);
1940         DPRINT5(DB_WR,"dgb%d: port%d: flush: head=%d tail=%d\n",
1941                         port->unit, port->pnum, head, tail);
1942 }
1943
1944 static int
1945 dgbparam(tp, t)
1946         struct tty      *tp;
1947         struct termios  *t;
1948 {
1949         int unit=MINOR_TO_UNIT(minor(tp->t_dev));
1950         int pnum=MINOR_TO_PORT(minor(tp->t_dev));
1951         struct dgb_softc *sc=&dgb_softc[unit];
1952         struct dgb_p *port=&sc->ports[pnum];
1953         volatile struct board_chan *bc=port->brdchan;
1954         int cflag;
1955         int head;
1956         int mval;
1957         int iflag;
1958         int hflow;
1959
1960         lwkt_gettoken(&tty_token);
1961         BoardMemWinState ws=bmws_get();
1962
1963         DPRINT6(DB_PARAM,"dgb%d: port%d: dgbparm c=0x%x i=0x%x l=0x%x\n",unit,pnum,t->c_cflag,t->c_iflag,t->c_lflag);
1964
1965         if(port->mustdrain) {
1966                 DPRINT3(DB_PARAM,"dgb%d: port%d: must call dgbdrain()\n",unit,pnum);
1967                 dgbdrain(port);
1968         }
1969
1970         cflag=ttspeedtab(t->c_ospeed, dgbspeedtab);
1971
1972         if (t->c_ispeed == 0)
1973                 t->c_ispeed = t->c_ospeed;
1974
1975         if (cflag < 0 /* || cflag > 0 && t->c_ispeed != t->c_ospeed */) {
1976                 DPRINT4(DB_PARAM,"dgb%d: port%d: invalid cflag=0%o\n",unit,pnum,cflag);
1977                 lwkt_reltoken(&tty_token);
1978                 return (EINVAL);
1979         }
1980
1981         crit_enter();
1982         setwin(sc,0);
1983
1984         if(cflag==0) { /* hangup */
1985                 DPRINT3(DB_PARAM,"dgb%d: port%d: hangup\n",unit,pnum);
1986                 head=bc->rin;
1987                 bc->rout=head;
1988                 head=bc->tin;
1989                 fepcmd(port, STOUT, (unsigned)head, 0, 0, 0);
1990                 mval= port->omodem & ~(DTR|RTS);
1991         } else {
1992                 cflag |= dgbflags(dgb_cflags, t->c_cflag);
1993
1994                 if(cflag!=port->fepcflag) {
1995                         port->fepcflag=cflag;
1996                         DPRINT5(DB_PARAM,"dgb%d: port%d: set cflag=0x%x c=0x%x\n",
1997                                         unit,pnum,cflag,t->c_cflag&~CRTSCTS);
1998                         fepcmd(port, SETCTRLFLAGS, (unsigned)cflag, 0, 0, 0);
1999                 }
2000                 mval= port->omodem | (DTR|RTS);
2001         }
2002
2003         iflag=dgbflags(dgb_iflags, t->c_iflag);
2004         if(iflag!=port->fepiflag) {
2005                 port->fepiflag=iflag;
2006                 DPRINT5(DB_PARAM,"dgb%d: port%d: set iflag=0x%x c=0x%x\n",unit,pnum,iflag,t->c_iflag);
2007                 fepcmd(port, SETIFLAGS, (unsigned)iflag, 0, 0, 0);
2008         }
2009
2010         bc->mint=port->dcd;
2011
2012         hflow=dgbflags(dgb_flow, t->c_cflag);
2013         if(hflow!=port->hflow) {
2014                 port->hflow=hflow;
2015                 DPRINT5(DB_PARAM,"dgb%d: port%d: set hflow=0x%x f=0x%x\n",unit,pnum,hflow,t->c_cflag&CRTSCTS);
2016                 fepcmd(port, SETHFLOW, (unsigned)hflow, 0xff, 0, 1);
2017         }
2018         
2019         if(port->omodem != mval) {
2020                 DPRINT5(DB_PARAM,"dgb%d: port%d: setting modem parameters 0x%x was 0x%x\n",
2021                         unit,pnum,mval,port->omodem);
2022                 port->omodem=mval;
2023                 fepcmd(port, SETMODEM, (unsigned)mval, RTS|DTR, 0, 1);
2024         }
2025
2026         if(port->fepstartc!=t->c_cc[VSTART] || port->fepstopc!=t->c_cc[VSTOP]) {
2027                 DPRINT5(DB_PARAM,"dgb%d: port%d: set startc=%d, stopc=%d\n",unit,pnum,t->c_cc[VSTART],t->c_cc[VSTOP]);
2028                 port->fepstartc=t->c_cc[VSTART];
2029                 port->fepstopc=t->c_cc[VSTOP];
2030                 fepcmd(port, SONOFFC, port->fepstartc, port->fepstopc, 0, 1);
2031         }
2032
2033         bmws_set(ws);
2034         crit_exit();
2035
2036         lwkt_reltoken(&tty_token);
2037         return 0;
2038
2039 }
2040
2041 static void
2042 dgbstart(tp)
2043         struct tty      *tp;
2044 {
2045         int unit;
2046         int pnum;
2047         struct dgb_p *port;
2048         struct dgb_softc *sc;
2049         volatile struct board_chan *bc;
2050         int head, tail;
2051         int size, ocount;
2052         int wmask;
2053
2054         lwkt_gettoken(&tty_token);
2055         BoardMemWinState ws=bmws_get();
2056
2057         unit=MINOR_TO_UNIT(minor(tp->t_dev));
2058         pnum=MINOR_TO_PORT(minor(tp->t_dev));
2059         sc=&dgb_softc[unit];
2060         port=&sc->ports[pnum];
2061         bc=port->brdchan;
2062
2063         wmask=port->txbufsize-1;
2064
2065         crit_enter();
2066
2067         while( tp->t_outq.c_cc!=0 ) {
2068                 int cs;
2069 #ifndef TS_ASLEEP       /* post 2.0.5 FreeBSD */
2070                 ttwwakeup(tp);
2071 #else
2072                 if(tp->t_outq.c_cc <= tp->t_lowat) {
2073                         if(tp->t_state & TS_ASLEEP) {
2074                                 tp->t_state &= ~TS_ASLEEP;
2075                                 wakeup(TSA_OLOWAT(tp));
2076                         }
2077                         /*selwakeup(&tp->t_wsel);*/
2078                 }
2079 #endif
2080                 crit_exit();
2081                 setwin(sc,0);
2082
2083                 head=bc->tin & wmask;
2084
2085                 do { tail=bc->tout; } while (tail != bc->tout);
2086                 tail=bc->tout & wmask;
2087
2088                 DPRINT5(DB_WR,"dgb%d: port%d: s tx head=%d tail=%d\n",unit,pnum,head,tail);
2089
2090 #ifdef LEAVE_FREE_CHARS 
2091                 if(tail>head) {
2092                         size=tail-head-LEAVE_FREE_CHARS;
2093                         if (size <0)
2094                                 size=0;
2095                         } else {
2096                                 size=port->txbufsize-head;
2097                                 if(tail+port->txbufsize < head)
2098                                         size=0;
2099                         }
2100                 }
2101 #else
2102                 if(tail>head)
2103                         size=tail-head-1;
2104                 else {
2105                         size=port->txbufsize-head/*-1*/;
2106                         if(tail==0)
2107                                 size--;
2108                 }
2109 #endif
2110
2111                 if(size==0) {
2112                         bc->iempty=1; bc->ilow=1;
2113                         crit_exit();
2114                         bmws_set(ws);
2115                         tp->t_state|=TS_BUSY;
2116                         crit_exit();
2117                         lwkt_reltoken(&tty_token);
2118                         return;
2119                 }
2120
2121                 towin(sc,port->txwin);
2122
2123                 ocount=q_to_b(&tp->t_outq, __DEVOLATILE(u_char *, port->txptr+head), size);
2124                 head+=ocount;
2125                 if(head>=port->txbufsize)
2126                         head-=port->txbufsize;
2127
2128                 setwin(sc,0);
2129                 bc->tin=head;
2130
2131                 DPRINT5(DB_WR,"dgb%d: port%d: tx avail=%d count=%d\n",unit,pnum,size,ocount);
2132                 hidewin(sc);
2133                 crit_exit();
2134         }
2135
2136         bmws_set(ws);
2137         crit_exit();
2138
2139 #ifndef TS_ASLEEP       /* post 2.0.5 FreeBSD */
2140         if(tp->t_state & TS_BUSY) {     
2141                 tp->t_state&=~TS_BUSY;
2142                 linesw[tp->t_line].l_start(tp);
2143                 ttwwakeup(tp);
2144         }
2145 #else
2146         if(tp->t_state & TS_ASLEEP) {
2147                 tp->t_state &= ~TS_ASLEEP;
2148                 wakeup(TSA_OLOWAT(tp));
2149         }
2150         tp->t_state&=~TS_BUSY;
2151 #endif
2152         lwkt_reltoken(&tty_token);
2153 }
2154
2155 void
2156 dgbstop(tp, rw)
2157         struct tty      *tp;
2158         int             rw;
2159 {
2160         int unit;
2161         int pnum;
2162         struct dgb_p *port;
2163         struct dgb_softc *sc;
2164         volatile struct board_chan *bc;
2165
2166         lwkt_gettoken(&tty_token);
2167         BoardMemWinState ws=bmws_get();
2168
2169         unit=MINOR_TO_UNIT(minor(tp->t_dev));
2170         pnum=MINOR_TO_PORT(minor(tp->t_dev));
2171
2172         sc=&dgb_softc[unit];
2173         port=&sc->ports[pnum];
2174         bc=port->brdchan;
2175
2176         DPRINT3(DB_WR,"dgb%d: port%d: stop\n",port->unit, port->pnum);
2177
2178         crit_enter();
2179         setwin(sc,0);
2180
2181         if (rw & FWRITE) {
2182                 /* clear output queue */
2183                 bc->tout=bc->tin=0;
2184                 bc->ilow=0;bc->iempty=0;
2185         }
2186         if (rw & FREAD) {
2187                 /* clear input queue */
2188                 bc->rout=bc->rin;
2189                 bc->idata=1;
2190         }
2191         hidewin(sc);
2192         bmws_set(ws);
2193         crit_exit();
2194         dgbstart(tp);
2195         lwkt_reltoken(&tty_token);
2196 }
2197
2198 /*
2199  * NOTE: Must be called with tty_token held
2200  */
2201 static void 
2202 fepcmd(port, cmd, op1, op2, ncmds, bytecmd)
2203         struct dgb_p *port;
2204         unsigned cmd, op1, op2, ncmds, bytecmd;
2205 {
2206         struct dgb_softc *sc=&dgb_softc[port->unit];
2207         u_char *mem=sc->vmem;
2208         unsigned tail, head;
2209         int count, n;
2210
2211         ASSERT_LWKT_TOKEN_HELD(&tty_token);
2212
2213         if(port->status==DISABLED) {
2214                 kprintf("dgb%d: port%d: FEP command on disabled port\n", 
2215                         port->unit, port->pnum);
2216                 return;
2217         }
2218
2219         /* setwin(sc,0); Require this to be set by caller */
2220         head=sc->mailbox->cin;
2221
2222         if(head>=(FEP_CMAX-FEP_CSTART) || (head & 3)) {
2223                 kprintf("dgb%d: port%d: wrong pointer head of command queue : 0x%x\n",
2224                         port->unit, port->pnum, head);
2225                 return;
2226         }
2227
2228         mem[head+FEP_CSTART+0]=cmd;
2229         mem[head+FEP_CSTART+1]=port->pnum;
2230         if(bytecmd) {
2231                 mem[head+FEP_CSTART+2]=op1;
2232                 mem[head+FEP_CSTART+3]=op2;
2233         } else {
2234                 mem[head+FEP_CSTART+2]=op1&0xff;
2235                 mem[head+FEP_CSTART+3]=(op1>>8)&0xff;
2236         }
2237
2238         DPRINT7(DB_FEP,"dgb%d: port%d: %s cmd=0x%x op1=0x%x op2=0x%x\n", port->unit, port->pnum,
2239                         (bytecmd)?"byte":"word", cmd, mem[head+FEP_CSTART+2], mem[head+FEP_CSTART+3]);
2240
2241         head=(head+4) & (FEP_CMAX-FEP_CSTART-4);
2242         sc->mailbox->cin=head;
2243
2244         count=FEPTIMEOUT;
2245
2246         while (count-- != 0) {
2247                 head=sc->mailbox->cin;
2248                 tail=sc->mailbox->cout;
2249
2250                 n = (head-tail) & (FEP_CMAX-FEP_CSTART-4);
2251                 if(n <= ncmds * (sizeof(ushort)*4))
2252                         return;
2253         }
2254         kprintf("dgb%d(%d): timeout on FEP cmd=0x%x\n", port->unit, port->pnum, cmd);
2255 }
2256
2257 static void 
2258 disc_optim(tp, t)
2259         struct tty      *tp;
2260         struct termios  *t;
2261 {
2262         lwkt_gettoken(&tty_token);
2263         if (!(t->c_iflag & (ICRNL | IGNCR | IMAXBEL | INLCR | ISTRIP | IXON))
2264             && (!(t->c_iflag & BRKINT) || (t->c_iflag & IGNBRK))
2265             && (!(t->c_iflag & PARMRK)
2266                 || (t->c_iflag & (IGNPAR | IGNBRK)) == (IGNPAR | IGNBRK))
2267             && !(t->c_lflag & (ECHO | ICANON | IEXTEN | ISIG | PENDIN))
2268             && linesw[tp->t_line].l_rint == ttyinput)
2269                 tp->t_state |= TS_CAN_BYPASS_L_RINT;
2270         else
2271                 tp->t_state &= ~TS_CAN_BYPASS_L_RINT;
2272         lwkt_reltoken(&tty_token);
2273 }