![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dcm.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / arch / hp300 / dev|
Return to dcm.c CVS log | Up to [Net/2] / Net2 / arch / hp300 / dev |
1.1 root 1: /*
2: * Copyright (c) 1988 University of Utah.
3: * Copyright (c) 1982, 1986, 1990 The Regents of the University of California.
4: * All rights reserved.
5: *
6: * This code is derived from software contributed to Berkeley by
7: * the Systems Programming Group of the University of Utah Computer
8: * Science Department.
9: *
10: * Redistribution and use in source and binary forms, with or without
11: * modification, are permitted provided that the following conditions
12: * are met:
13: * 1. Redistributions of source code must retain the above copyright
14: * notice, this list of conditions and the following disclaimer.
15: * 2. Redistributions in binary form must reproduce the above copyright
16: * notice, this list of conditions and the following disclaimer in the
17: * documentation and/or other materials provided with the distribution.
18: * 3. All advertising materials mentioning features or use of this software
19: * must display the following acknowledgement:
20: * This product includes software developed by the University of
21: * California, Berkeley and its contributors.
22: * 4. Neither the name of the University nor the names of its contributors
23: * may be used to endorse or promote products derived from this software
24: * without specific prior written permission.
25: *
26: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36: * SUCH DAMAGE.
37: *
38: * from: $Hdr: dcm.c 1.26 91/01/21$
39: *
40: * @(#)dcm.c 7.14 (Berkeley) 6/27/91
41: */
42:
43: /*
44: * TODO:
45: * Timeouts
46: * Test console support.
47: */
48:
49: #include "dcm.h"
50: #if NDCM > 0
51: /*
52: * 98642/MUX
53: */
54: #include "sys/param.h"
55: #include "sys/systm.h"
56: #include "sys/ioctl.h"
57: #include "sys/tty.h"
58: #include "sys/proc.h"
59: #include "sys/conf.h"
60: #include "sys/file.h"
61: #include "sys/uio.h"
62: #include "sys/kernel.h"
63: #include "sys/syslog.h"
64: #include "sys/time.h"
65:
66: #include "device.h"
67: #include "dcmreg.h"
68: #include "machine/cpu.h"
69: #include "../hp300/isr.h"
70:
71: #ifndef DEFAULT_BAUD_RATE
72: #define DEFAULT_BAUD_RATE 9600
73: #endif
74:
75: int ttrstrt();
76: int dcmprobe(), dcmstart(), dcmintr(), dcmparam();
77:
78: struct driver dcmdriver = {
79: dcmprobe, "dcm",
80: };
81:
82: #define NDCMLINE (NDCM*4)
83:
84: struct tty dcm_tty[NDCMLINE];
85: struct modemreg *dcm_modem[NDCMLINE];
86: char mcndlast[NDCMLINE]; /* XXX last modem status for line */
87: int ndcm = NDCMLINE;
88:
89: int dcm_active;
90: int dcmsoftCAR[NDCM];
91: struct dcmdevice *dcm_addr[NDCM];
92: struct isr dcmisr[NDCM];
93:
94: struct speedtab dcmspeedtab[] = {
95: 0, BR_0,
96: 50, BR_50,
97: 75, BR_75,
98: 110, BR_110,
99: 134, BR_134,
100: 150, BR_150,
101: 300, BR_300,
102: 600, BR_600,
103: 1200, BR_1200,
104: 1800, BR_1800,
105: 2400, BR_2400,
106: 4800, BR_4800,
107: 9600, BR_9600,
108: 19200, BR_19200,
109: 38400, BR_38400,
110: -1, -1
111: };
112:
113: /* u-sec per character based on baudrate (assumes 1 start/8 data/1 stop bit) */
114: #define DCM_USPERCH(s) (10000000 / (s))
115:
116: /*
117: * Per board interrupt scheme. 16.7ms is the polling interrupt rate
118: * (16.7ms is about 550 baud, 38.4k is 72 chars in 16.7ms).
119: */
120: #define DIS_TIMER 0
121: #define DIS_PERCHAR 1
122: #define DIS_RESET 2
123:
124: int dcmistype = -1; /* -1 == dynamic, 0 == timer, 1 == perchar */
125: int dcminterval = 5; /* interval (secs) between checks */
126: struct dcmischeme {
127: int dis_perchar; /* non-zero if interrupting per char */
128: long dis_time; /* last time examined */
129: int dis_intr; /* recv interrupts during last interval */
130: int dis_char; /* characters read during last interval */
131: } dcmischeme[NDCM];
132:
133: /*
134: * Console support
135: */
136: #ifdef DCMCONSOLE
137: int dcmconsole = DCMCONSOLE;
138: #else
139: int dcmconsole = -1;
140: #endif
141: int dcmconsinit;
142: int dcmdefaultrate = DEFAULT_BAUD_RATE;
143: int dcmconbrdbusy = 0;
144: int dcmmajor;
145: extern struct tty *constty;
146:
147: #ifdef KGDB
148: /*
149: * Kernel GDB support
150: */
151: #include "machine/remote-sl.h"
152:
153: extern dev_t kgdb_dev;
154: extern int kgdb_rate;
155: extern int kgdb_debug_init;
156: #endif
157:
158: /* #define IOSTATS */
159:
160: #ifdef DEBUG
161: int dcmdebug = 0x0;
162: #define DDB_SIOERR 0x01
163: #define DDB_PARAM 0x02
164: #define DDB_INPUT 0x04
165: #define DDB_OUTPUT 0x08
166: #define DDB_INTR 0x10
167: #define DDB_IOCTL 0x20
168: #define DDB_INTSCHM 0x40
169: #define DDB_MODEM 0x80
170: #define DDB_OPENCLOSE 0x100
171: #endif
172:
173: #ifdef IOSTATS
174: #define DCMRBSIZE 94
175: #define DCMXBSIZE 24
176:
177: struct dcmstats {
178: long xints; /* # of xmit ints */
179: long xchars; /* # of xmit chars */
180: long xempty; /* times outq is empty in dcmstart */
181: long xrestarts; /* times completed while xmitting */
182: long rints; /* # of recv ints */
183: long rchars; /* # of recv chars */
184: long xsilo[DCMXBSIZE+2]; /* times this many chars xmit on one int */
185: long rsilo[DCMRBSIZE+2]; /* times this many chars read on one int */
186: } dcmstats[NDCM];
187: #endif
188:
189: #define UNIT(x) minor(x)
190: #define BOARD(x) (((x) >> 2) & 0x3f)
191: #define PORT(x) ((x) & 3)
192: #define MKUNIT(b,p) (((b) << 2) | (p))
193:
194: /*
195: * Conversion from "HP DCE" to almost-normal DCE: on the 638 8-port mux,
196: * the distribution panel uses "HP DCE" conventions. If requested via
197: * the device flags, we swap the inputs to something closer to normal DCE,
198: * allowing a straight-through cable to a DTE or a reversed cable
199: * to a DCE (reversing 2-3, 4-5, 8-20 and leaving 6 unconnected;
200: * this gets "DCD" on pin 20 and "CTS" on 4, but doesn't connect
201: * DSR or make RTS work, though). The following gives the full
202: * details of a cable from this mux panel to a modem:
203: *
204: * HP modem
205: * name pin pin name
206: * HP inputs:
207: * "Rx" 2 3 Tx
208: * CTS 4 5 CTS (only needed for CCTS_OFLOW)
209: * DCD 20 8 DCD
210: * "DSR" 9 6 DSR (unneeded)
211: * RI 22 22 RI (unneeded)
212: *
213: * HP outputs:
214: * "Tx" 3 2 Rx
215: * "DTR" 6 not connected
216: * "RTS" 8 20 DTR
217: * "SR" 23 4 RTS (often not needed)
218: */
219: #define FLAG_STDDCE 0x10 /* map inputs if this bit is set in flags */
220: #define hp2dce_in(ibits) (iconv[(ibits) & 0xf])
221: static char iconv[16] = {
222: 0, MI_DM, MI_CTS, MI_CTS|MI_DM,
223: MI_CD, MI_CD|MI_DM, MI_CD|MI_CTS, MI_CD|MI_CTS|MI_DM,
224: MI_RI, MI_RI|MI_DM, MI_RI|MI_CTS, MI_RI|MI_CTS|MI_DM,
225: MI_RI|MI_CD, MI_RI|MI_CD|MI_DM, MI_RI|MI_CD|MI_CTS,
226: MI_RI|MI_CD|MI_CTS|MI_DM
227: };
228:
229: dcmprobe(hd)
230: register struct hp_device *hd;
231: {
232: register struct dcmdevice *dcm;
233: register int i;
234: register int timo = 0;
235: int s, brd, isconsole, mbits;
236:
237: dcm = (struct dcmdevice *)hd->hp_addr;
238: if ((dcm->dcm_rsid & 0x1f) != DCMID)
239: return (0);
240: brd = hd->hp_unit;
241: isconsole = (brd == BOARD(dcmconsole));
242: /*
243: * XXX selected console device (CONSUNIT) as determined by
244: * dcmcnprobe does not agree with logical numbering imposed
245: * by the config file (i.e. lowest address DCM is not unit
246: * CONSUNIT). Don't recognize this card.
247: */
248: if (isconsole && dcm != dcm_addr[BOARD(dcmconsole)])
249: return (0);
250:
251: /*
252: * Empirically derived self-test magic
253: */
254: s = spltty();
255: dcm->dcm_rsid = DCMRS;
256: DELAY(50000); /* 5000 is not long enough */
257: dcm->dcm_rsid = 0;
258: dcm->dcm_ic = IC_IE;
259: dcm->dcm_cr = CR_SELFT;
260: while ((dcm->dcm_ic & IC_IR) == 0)
261: if (++timo == 20000)
262: return (0);
263: DELAY(50000) /* XXX why is this needed ???? */
264: while ((dcm->dcm_iir & IIR_SELFT) == 0)
265: if (++timo == 400000)
266: return (0);
267: DELAY(50000) /* XXX why is this needed ???? */
268: if (dcm->dcm_stcon != ST_OK) {
269: if (!isconsole)
270: printf("dcm%d: self test failed: %x\n",
271: brd, dcm->dcm_stcon);
272: return (0);
273: }
274: dcm->dcm_ic = IC_ID;
275: splx(s);
276:
277: hd->hp_ipl = DCMIPL(dcm->dcm_ic);
278: dcm_addr[brd] = dcm;
279: dcm_active |= 1 << brd;
280: dcmsoftCAR[brd] = hd->hp_flags;
281: dcmisr[brd].isr_ipl = hd->hp_ipl;
282: dcmisr[brd].isr_arg = brd;
283: dcmisr[brd].isr_intr = dcmintr;
284: isrlink(&dcmisr[brd]);
285: #ifdef KGDB
286: if (major(kgdb_dev) == dcmmajor && BOARD(kgdb_dev) == brd) {
287: if (dcmconsole == UNIT(kgdb_dev))
288: kgdb_dev = NODEV; /* can't debug over console port */
289: #ifndef KGDB_CHEAT
290: /*
291: * The following could potentially be replaced
292: * by the corresponding code in dcmcnprobe.
293: */
294: else {
295: (void) dcminit(kgdb_dev, kgdb_rate);
296: if (kgdb_debug_init) {
297: printf("dcm%d: ", UNIT(kgdb_dev));
298: kgdb_connect(1);
299: } else
300: printf("dcm%d: kgdb enabled\n", UNIT(kgdb_dev));
301: }
302: /* end could be replaced */
303: #endif
304: }
305: #endif
306: if (dcmistype == DIS_TIMER)
307: dcmsetischeme(brd, DIS_RESET|DIS_TIMER);
308: else
309: dcmsetischeme(brd, DIS_RESET|DIS_PERCHAR);
310:
311: /* load pointers to modem control */
312: dcm_modem[MKUNIT(brd, 0)] = &dcm->dcm_modem0;
313: dcm_modem[MKUNIT(brd, 1)] = &dcm->dcm_modem1;
314: dcm_modem[MKUNIT(brd, 2)] = &dcm->dcm_modem2;
315: dcm_modem[MKUNIT(brd, 3)] = &dcm->dcm_modem3;
316: /* set DCD (modem) and CTS (flow control) on all ports */
317: if (dcmsoftCAR[brd] & FLAG_STDDCE)
318: mbits = hp2dce_in(MI_CD|MI_CTS);
319: else
320: mbits = MI_CD|MI_CTS;
321: for (i = 0; i < 4; i++)
322: dcm_modem[MKUNIT(brd, i)]->mdmmsk = mbits;
323:
324: dcm->dcm_ic = IC_IE; /* turn all interrupts on */
325: /*
326: * Need to reset baud rate, etc. of next print so reset dcmconsole.
327: * Also make sure console is always "hardwired"
328: */
329: if (isconsole) {
330: dcmconsinit = 0;
331: dcmsoftCAR[brd] |= (1 << PORT(dcmconsole));
332: }
333: return (1);
334: }
335:
336: /* ARGSUSED */
337: #ifdef __STDC__
338: dcmopen(dev_t dev, int flag, int mode, struct proc *p)
339: #else
340: dcmopen(dev, flag, mode, p)
341: dev_t dev;
342: int flag, mode;
343: struct proc *p;
344: #endif
345: {
346: register struct tty *tp;
347: register int unit, brd;
348: int error = 0, mbits;
349:
350: unit = UNIT(dev);
351: brd = BOARD(unit);
352: if (unit >= NDCMLINE || (dcm_active & (1 << brd)) == 0)
353: return (ENXIO);
354: tp = &dcm_tty[unit];
355: tp->t_oproc = dcmstart;
356: tp->t_param = dcmparam;
357: tp->t_dev = dev;
358: if ((tp->t_state & TS_ISOPEN) == 0) {
359: tp->t_state |= TS_WOPEN;
360: ttychars(tp);
361: if (tp->t_ispeed == 0) {
362: tp->t_iflag = TTYDEF_IFLAG;
363: tp->t_oflag = TTYDEF_OFLAG;
364: tp->t_cflag = TTYDEF_CFLAG;
365: tp->t_lflag = TTYDEF_LFLAG;
366: tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
367: }
368: (void) dcmparam(tp, &tp->t_termios);
369: ttsetwater(tp);
370: } else if (tp->t_state&TS_XCLUDE && p->p_ucred->cr_uid != 0)
371: return (EBUSY);
372: mbits = MO_ON;
373: if (dcmsoftCAR[brd] & FLAG_STDDCE)
374: mbits |= MO_SR; /* pin 23, could be used as RTS */
375: (void) dcmmctl(dev, mbits, DMSET); /* enable port */
376: if ((dcmsoftCAR[brd] & (1 << PORT(unit))) ||
377: (dcmmctl(dev, MO_OFF, DMGET) & MI_CD))
378: tp->t_state |= TS_CARR_ON;
379: #ifdef DEBUG
380: if (dcmdebug & DDB_MODEM)
381: printf("dcm%d: dcmopen port %d softcarr %c\n",
382: brd, unit, (tp->t_state & TS_CARR_ON) ? '1' : '0');
383: #endif
384: (void) spltty();
385: while ((flag&O_NONBLOCK) == 0 && (tp->t_cflag&CLOCAL) == 0 &&
386: (tp->t_state & TS_CARR_ON) == 0) {
387: tp->t_state |= TS_WOPEN;
388: if (error = ttysleep(tp, (caddr_t)&tp->t_rawq, TTIPRI | PCATCH,
389: ttopen, 0))
390: break;
391: }
392: (void) spl0();
393:
394: #ifdef DEBUG
395: if (dcmdebug & DDB_OPENCLOSE)
396: printf("dcmopen: u %x st %x fl %x\n",
397: unit, tp->t_state, tp->t_flags);
398: #endif
399: if (error == 0)
400: error = (*linesw[tp->t_line].l_open)(dev, tp);
401: return (error);
402: }
403:
404: /*ARGSUSED*/
405: dcmclose(dev, flag, mode, p)
406: dev_t dev;
407: int flag, mode;
408: struct proc *p;
409: {
410: register struct tty *tp;
411: int unit;
412:
413: unit = UNIT(dev);
414: tp = &dcm_tty[unit];
415: (*linesw[tp->t_line].l_close)(tp, flag);
416: if (tp->t_cflag&HUPCL || tp->t_state&TS_WOPEN ||
417: (tp->t_state&TS_ISOPEN) == 0)
418: (void) dcmmctl(dev, MO_OFF, DMSET);
419: #ifdef DEBUG
420: if (dcmdebug & DDB_OPENCLOSE)
421: printf("dcmclose: u %x st %x fl %x\n",
422: unit, tp->t_state, tp->t_flags);
423: #endif
424: ttyclose(tp);
425: return (0);
426: }
427:
428: dcmread(dev, uio, flag)
429: dev_t dev;
430: struct uio *uio;
431: {
432: register struct tty *tp;
433:
434: tp = &dcm_tty[UNIT(dev)];
435: return ((*linesw[tp->t_line].l_read)(tp, uio, flag));
436: }
437:
438: dcmwrite(dev, uio, flag)
439: dev_t dev;
440: struct uio *uio;
441: {
442: int unit = UNIT(dev);
443: register struct tty *tp;
444:
445: tp = &dcm_tty[unit];
446: /*
447: * XXX we disallow virtual consoles if the physical console is
448: * a serial port. This is in case there is a display attached that
449: * is not the console. In that situation we don't need/want the X
450: * server taking over the console.
451: */
452: if (constty && unit == dcmconsole)
453: constty = NULL;
454: return ((*linesw[tp->t_line].l_write)(tp, uio, flag));
455: }
456:
457: dcmintr(brd)
458: register int brd;
459: {
460: register struct dcmdevice *dcm = dcm_addr[brd];
461: register struct dcmischeme *dis;
462: register int unit = MKUNIT(brd, 0);
463: register int code, i;
464: int pcnd[4], mcode, mcnd[4];
465:
466: /*
467: * Do all guarded register accesses right off to minimize
468: * block out of hardware.
469: */
470: SEM_LOCK(dcm);
471: if ((dcm->dcm_ic & IC_IR) == 0) {
472: SEM_UNLOCK(dcm);
473: return (0);
474: }
475: for (i = 0; i < 4; i++) {
476: pcnd[i] = dcm->dcm_icrtab[i].dcm_data;
477: dcm->dcm_icrtab[i].dcm_data = 0;
478: code = dcm_modem[unit+i]->mdmin;
479: if (dcmsoftCAR[brd] & FLAG_STDDCE)
480: code = hp2dce_in(code);
481: mcnd[i] = code;
482: }
483: code = dcm->dcm_iir & IIR_MASK;
484: dcm->dcm_iir = 0; /* XXX doc claims read clears interrupt?! */
485: mcode = dcm->dcm_modemintr;
486: dcm->dcm_modemintr = 0;
487: SEM_UNLOCK(dcm);
488:
489: #ifdef DEBUG
490: if (dcmdebug & DDB_INTR) {
491: printf("dcmintr(%d): iir %x pc %x/%x/%x/%x ",
492: brd, code, pcnd[0], pcnd[1], pcnd[2], pcnd[3]);
493: printf("miir %x mc %x/%x/%x/%x\n",
494: mcode, mcnd[0], mcnd[1], mcnd[2], mcnd[3]);
495: }
496: #endif
497: if (code & IIR_TIMEO)
498: dcmrint(brd, dcm);
499: if (code & IIR_PORT0)
500: dcmpint(unit+0, pcnd[0], dcm);
501: if (code & IIR_PORT1)
502: dcmpint(unit+1, pcnd[1], dcm);
503: if (code & IIR_PORT2)
504: dcmpint(unit+2, pcnd[2], dcm);
505: if (code & IIR_PORT3)
506: dcmpint(unit+3, pcnd[3], dcm);
507: if (code & IIR_MODM) {
508: if (mcode == 0 || mcode & 0x1) /* mcode==0 -> 98642 board */
509: dcmmint(unit+0, mcnd[0], dcm);
510: if (mcode & 0x2)
511: dcmmint(unit+1, mcnd[1], dcm);
512: if (mcode & 0x4)
513: dcmmint(unit+2, mcnd[2], dcm);
514: if (mcode & 0x8)
515: dcmmint(unit+3, mcnd[3], dcm);
516: }
517:
518: dis = &dcmischeme[brd];
519: /*
520: * Chalk up a receiver interrupt if the timer running or one of
521: * the ports reports a special character interrupt.
522: */
523: if ((code & IIR_TIMEO) ||
524: ((pcnd[0]|pcnd[1]|pcnd[2]|pcnd[3]) & IT_SPEC))
525: dis->dis_intr++;
526: /*
527: * See if it is time to check/change the interrupt rate.
528: */
529: if (dcmistype < 0 &&
530: (i = time.tv_sec - dis->dis_time) >= dcminterval) {
531: /*
532: * If currently per-character and averaged over 70 interrupts
533: * per-second (66 is threshold of 600 baud) in last interval,
534: * switch to timer mode.
535: *
536: * XXX decay counts ala load average to avoid spikes?
537: */
538: if (dis->dis_perchar && dis->dis_intr > 70 * i)
539: dcmsetischeme(brd, DIS_TIMER);
540: /*
541: * If currently using timer and had more interrupts than
542: * received characters in the last interval, switch back
543: * to per-character. Note that after changing to per-char
544: * we must process any characters already in the queue
545: * since they may have arrived before the bitmap was setup.
546: *
547: * XXX decay counts?
548: */
549: else if (!dis->dis_perchar && dis->dis_intr > dis->dis_char) {
550: dcmsetischeme(brd, DIS_PERCHAR);
551: dcmrint(brd, dcm);
552: }
553: dis->dis_intr = dis->dis_char = 0;
554: dis->dis_time = time.tv_sec;
555: }
556: return (1);
557: }
558:
559: /*
560: * Port interrupt. Can be two things:
561: * First, it might be a special character (exception interrupt);
562: * Second, it may be a buffer empty (transmit interrupt);
563: */
564: dcmpint(unit, code, dcm)
565: int unit, code;
566: struct dcmdevice *dcm;
567: {
568: struct tty *tp = &dcm_tty[unit];
569:
570: if (code & IT_SPEC)
571: dcmreadbuf(unit, dcm, tp);
572: if (code & IT_TX)
573: dcmxint(unit, dcm, tp);
574: }
575:
576: dcmrint(brd, dcm)
577: int brd;
578: register struct dcmdevice *dcm;
579: {
580: register int i, unit;
581: register struct tty *tp;
582:
583: unit = MKUNIT(brd, 0);
584: tp = &dcm_tty[unit];
585: for (i = 0; i < 4; i++, tp++, unit++)
586: dcmreadbuf(unit, dcm, tp);
587: }
588:
589: dcmreadbuf(unit, dcm, tp)
590: int unit;
591: register struct dcmdevice *dcm;
592: register struct tty *tp;
593: {
594: int port = PORT(unit);
595: register struct dcmpreg *pp = dcm_preg(dcm, port);
596: register struct dcmrfifo *fifo;
597: register int c, stat;
598: register unsigned head;
599: int nch = 0;
600: #ifdef IOSTATS
601: struct dcmstats *dsp = &dcmstats[BOARD(unit)];
602:
603: dsp->rints++;
604: #endif
605: if ((tp->t_state & TS_ISOPEN) == 0) {
606: #ifdef KGDB
607: if ((makedev(dcmmajor, unit) == kgdb_dev) &&
608: (head = pp->r_head & RX_MASK) != (pp->r_tail & RX_MASK) &&
609: dcm->dcm_rfifos[3-port][head>>1].data_char == FRAME_END) {
610: pp->r_head = (head + 2) & RX_MASK;
611: kgdb_connect(0); /* trap into kgdb */
612: return;
613: }
614: #endif /* KGDB */
615: pp->r_head = pp->r_tail & RX_MASK;
616: return;
617: }
618:
619: head = pp->r_head & RX_MASK;
620: fifo = &dcm->dcm_rfifos[3-port][head>>1];
621: /*
622: * XXX upper bound on how many chars we will take in one swallow?
623: */
624: while (head != (pp->r_tail & RX_MASK)) {
625: /*
626: * Get character/status and update head pointer as fast
627: * as possible to make room for more characters.
628: */
629: c = fifo->data_char;
630: stat = fifo->data_stat;
631: head = (head + 2) & RX_MASK;
632: pp->r_head = head;
633: fifo = head ? fifo+1 : &dcm->dcm_rfifos[3-port][0];
634: nch++;
635:
636: #ifdef DEBUG
637: if (dcmdebug & DDB_INPUT)
638: printf("dcmreadbuf(%d): c%x('%c') s%x f%x h%x t%x\n",
639: unit, c&0xFF, c, stat&0xFF,
640: tp->t_flags, head, pp->r_tail);
641: #endif
642: /*
643: * Check for and handle errors
644: */
645: if (stat & RD_MASK) {
646: #ifdef DEBUG
647: if (dcmdebug & (DDB_INPUT|DDB_SIOERR))
648: printf("dcmreadbuf(%d): err: c%x('%c') s%x\n",
649: unit, stat, c&0xFF, c);
650: #endif
651: if (stat & (RD_BD | RD_FE))
652: c |= TTY_FE;
653: else if (stat & RD_PE)
654: c |= TTY_PE;
655: else if (stat & RD_OVF)
656: log(LOG_WARNING,
657: "dcm%d: silo overflow\n", unit);
658: else if (stat & RD_OE)
659: log(LOG_WARNING,
660: "dcm%d: uart overflow\n", unit);
661: }
662: (*linesw[tp->t_line].l_rint)(c, tp);
663: }
664: dcmischeme[BOARD(unit)].dis_char += nch;
665: #ifdef IOSTATS
666: dsp->rchars += nch;
667: if (nch <= DCMRBSIZE)
668: dsp->rsilo[nch]++;
669: else
670: dsp->rsilo[DCMRBSIZE+1]++;
671: #endif
672: }
673:
674: dcmxint(unit, dcm, tp)
675: int unit;
676: struct dcmdevice *dcm;
677: register struct tty *tp;
678: {
679: tp->t_state &= ~TS_BUSY;
680: if (tp->t_state & TS_FLUSH)
681: tp->t_state &= ~TS_FLUSH;
682: (*linesw[tp->t_line].l_start)(tp);
683: }
684:
685: dcmmint(unit, mcnd, dcm)
686: register int unit;
687: register struct dcmdevice *dcm;
688: int mcnd;
689: {
690: register struct tty *tp;
691: int delta;
692:
693: #ifdef DEBUG
694: if (dcmdebug & DDB_MODEM)
695: printf("dcmmint: port %d mcnd %x mcndlast %x\n",
696: unit, mcnd, mcndlast[unit]);
697: #endif
698: tp = &dcm_tty[unit];
699: delta = mcnd ^ mcndlast[unit];
700: mcndlast[unit] = mcnd;
701: if ((delta & MI_CTS) && (tp->t_state & TS_ISOPEN) &&
702: (tp->t_flags & CCTS_OFLOW)) {
703: if (mcnd & MI_CTS) {
704: tp->t_state &= ~TS_TTSTOP;
705: ttstart(tp);
706: } else
707: tp->t_state |= TS_TTSTOP; /* inline dcmstop */
708: }
709: if (delta & MI_CD) {
710: if (mcnd & MI_CD)
711: (void)(*linesw[tp->t_line].l_modem)(tp, 1);
712: else if ((dcmsoftCAR[BOARD(unit)] & (1 << PORT(unit))) == 0 &&
713: (*linesw[tp->t_line].l_modem)(tp, 0) == 0) {
714: dcm_modem[unit]->mdmout = MO_OFF;
715: SEM_LOCK(dcm);
716: dcm->dcm_modemchng |= 1<<(unit & 3);
717: dcm->dcm_cr |= CR_MODM;
718: SEM_UNLOCK(dcm);
719: DELAY(10); /* time to change lines */
720: }
721: }
722: }
723:
724: dcmioctl(dev, cmd, data, flag)
725: dev_t dev;
726: caddr_t data;
727: {
728: register struct tty *tp;
729: register int unit = UNIT(dev);
730: register struct dcmdevice *dcm;
731: register int port;
732: int error, s;
733:
734: #ifdef DEBUG
735: if (dcmdebug & DDB_IOCTL)
736: printf("dcmioctl: unit %d cmd %x data %x flag %x\n",
737: unit, cmd, *data, flag);
738: #endif
739: tp = &dcm_tty[unit];
740: error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag);
741: if (error >= 0)
742: return (error);
743: error = ttioctl(tp, cmd, data, flag);
744: if (error >= 0)
745: return (error);
746:
747: port = PORT(unit);
748: dcm = dcm_addr[BOARD(unit)];
749: switch (cmd) {
750: case TIOCSBRK:
751: /*
752: * Wait for transmitter buffer to empty
753: */
754: s = spltty();
755: while (dcm->dcm_thead[port].ptr != dcm->dcm_ttail[port].ptr)
756: DELAY(DCM_USPERCH(tp->t_ospeed));
757: SEM_LOCK(dcm);
758: dcm->dcm_cmdtab[port].dcm_data |= CT_BRK;
759: dcm->dcm_cr |= (1 << port); /* start break */
760: SEM_UNLOCK(dcm);
761: splx(s);
762: break;
763:
764: case TIOCCBRK:
765: SEM_LOCK(dcm);
766: dcm->dcm_cmdtab[port].dcm_data |= CT_BRK;
767: dcm->dcm_cr |= (1 << port); /* end break */
768: SEM_UNLOCK(dcm);
769: break;
770:
771: case TIOCSDTR:
772: (void) dcmmctl(dev, MO_ON, DMBIS);
773: break;
774:
775: case TIOCCDTR:
776: (void) dcmmctl(dev, MO_ON, DMBIC);
777: break;
778:
779: case TIOCMSET:
780: (void) dcmmctl(dev, *(int *)data, DMSET);
781: break;
782:
783: case TIOCMBIS:
784: (void) dcmmctl(dev, *(int *)data, DMBIS);
785: break;
786:
787: case TIOCMBIC:
788: (void) dcmmctl(dev, *(int *)data, DMBIC);
789: break;
790:
791: case TIOCMGET:
792: *(int *)data = dcmmctl(dev, 0, DMGET);
793: break;
794:
795: default:
796: return (ENOTTY);
797: }
798: return (0);
799: }
800:
801: dcmparam(tp, t)
802: register struct tty *tp;
803: register struct termios *t;
804: {
805: register struct dcmdevice *dcm;
806: register int port, mode, cflag = t->c_cflag;
807: int ospeed = ttspeedtab(t->c_ospeed, dcmspeedtab);
808:
809: /* check requested parameters */
810: if (ospeed < 0 || (t->c_ispeed && t->c_ispeed != t->c_ospeed))
811: return (EINVAL);
812: /* and copy to tty */
813: tp->t_ispeed = t->c_ispeed;
814: tp->t_ospeed = t->c_ospeed;
815: tp->t_cflag = cflag;
816: if (ospeed == 0) {
817: (void) dcmmctl(UNIT(tp->t_dev), MO_OFF, DMSET);
818: return (0);
819: }
820:
821: mode = 0;
822: switch (cflag&CSIZE) {
823: case CS5:
824: mode = LC_5BITS; break;
825: case CS6:
826: mode = LC_6BITS; break;
827: case CS7:
828: mode = LC_7BITS; break;
829: case CS8:
830: mode = LC_8BITS; break;
831: }
832: if (cflag&PARENB) {
833: if (cflag&PARODD)
834: mode |= LC_PODD;
835: else
836: mode |= LC_PEVEN;
837: }
838: if (cflag&CSTOPB)
839: mode |= LC_2STOP;
840: else
841: mode |= LC_1STOP;
842: #ifdef DEBUG
843: if (dcmdebug & DDB_PARAM)
844: printf("dcmparam(%d): cflag %x mode %x speed %d uperch %d\n",
845: UNIT(tp->t_dev), cflag, mode, tp->t_ospeed,
846: DCM_USPERCH(tp->t_ospeed));
847: #endif
848:
849: port = PORT(tp->t_dev);
850: dcm = dcm_addr[BOARD(tp->t_dev)];
851: /*
852: * Wait for transmitter buffer to empty.
853: */
854: while (dcm->dcm_thead[port].ptr != dcm->dcm_ttail[port].ptr)
855: DELAY(DCM_USPERCH(tp->t_ospeed));
856: /*
857: * Make changes known to hardware.
858: */
859: dcm->dcm_data[port].dcm_baud = ospeed;
860: dcm->dcm_data[port].dcm_conf = mode;
861: SEM_LOCK(dcm);
862: dcm->dcm_cmdtab[port].dcm_data |= CT_CON;
863: dcm->dcm_cr |= (1 << port);
864: SEM_UNLOCK(dcm);
865: /*
866: * Delay for config change to take place. Weighted by baud.
867: * XXX why do we do this?
868: */
869: DELAY(16 * DCM_USPERCH(tp->t_ospeed));
870: return (0);
871: }
872:
873: dcmstart(tp)
874: register struct tty *tp;
875: {
876: register struct dcmdevice *dcm;
877: register struct dcmpreg *pp;
878: register struct dcmtfifo *fifo;
879: register char *bp;
880: register unsigned tail, next;
881: register int port, nch;
882: unsigned head;
883: char buf[16];
884: int s;
885: #ifdef IOSTATS
886: struct dcmstats *dsp = &dcmstats[BOARD(tp->t_dev)];
887: int tch = 0;
888: #endif
889:
890: s = spltty();
891: #ifdef IOSTATS
892: dsp->xints++;
893: #endif
894: #ifdef DEBUG
895: if (dcmdebug & DDB_OUTPUT)
896: printf("dcmstart(%d): state %x flags %x outcc %d\n",
897: UNIT(tp->t_dev), tp->t_state, tp->t_flags,
898: tp->t_outq.c_cc);
899: #endif
900: if (tp->t_state & (TS_TIMEOUT|TS_BUSY|TS_TTSTOP))
901: goto out;
902: if (tp->t_outq.c_cc <= tp->t_lowat) {
903: if (tp->t_state&TS_ASLEEP) {
904: tp->t_state &= ~TS_ASLEEP;
905: wakeup((caddr_t)&tp->t_outq);
906: }
907: if (tp->t_wsel) {
908: selwakeup(tp->t_wsel, tp->t_state & TS_WCOLL);
909: tp->t_wsel = 0;
910: tp->t_state &= ~TS_WCOLL;
911: }
912: }
913: if (tp->t_outq.c_cc == 0) {
914: #ifdef IOSTATS
915: dsp->xempty++;
916: #endif
917: goto out;
918: }
919:
920: dcm = dcm_addr[BOARD(tp->t_dev)];
921: port = PORT(tp->t_dev);
922: pp = dcm_preg(dcm, port);
923: tail = pp->t_tail & TX_MASK;
924: next = (tail + 1) & TX_MASK;
925: head = pp->t_head & TX_MASK;
926: if (head == next)
927: goto out;
928: fifo = &dcm->dcm_tfifos[3-port][tail];
929: again:
930: nch = q_to_b(&tp->t_outq, buf, (head - next) & TX_MASK);
931: #ifdef IOSTATS
932: tch += nch;
933: #endif
934: #ifdef DEBUG
935: if (dcmdebug & DDB_OUTPUT)
936: printf("\thead %x tail %x nch %d\n", head, tail, nch);
937: #endif
938: /*
939: * Loop transmitting all the characters we can.
940: */
941: for (bp = buf; --nch >= 0; bp++) {
942: fifo->data_char = *bp;
943: pp->t_tail = next;
944: /*
945: * If this is the first character,
946: * get the hardware moving right now.
947: */
948: if (bp == buf) {
949: tp->t_state |= TS_BUSY;
950: SEM_LOCK(dcm);
951: dcm->dcm_cmdtab[port].dcm_data |= CT_TX;
952: dcm->dcm_cr |= (1 << port);
953: SEM_UNLOCK(dcm);
954: }
955: tail = next;
956: fifo = tail ? fifo+1 : &dcm->dcm_tfifos[3-port][0];
957: next = (next + 1) & TX_MASK;
958: }
959: /*
960: * Head changed while we were loading the buffer,
961: * go back and load some more if we can.
962: */
963: if (tp->t_outq.c_cc && head != (pp->t_head & TX_MASK)) {
964: #ifdef IOSTATS
965: dsp->xrestarts++;
966: #endif
967: head = pp->t_head & TX_MASK;
968: goto again;
969: }
970:
971: /*
972: * Kick it one last time in case it finished while we were
973: * loading the last bunch.
974: */
975: if (bp > &buf[1]) {
976: tp->t_state |= TS_BUSY;
977: SEM_LOCK(dcm);
978: dcm->dcm_cmdtab[port].dcm_data |= CT_TX;
979: dcm->dcm_cr |= (1 << port);
980: SEM_UNLOCK(dcm);
981: }
982: #ifdef DEBUG
983: if (dcmdebug & DDB_INTR)
984: printf("dcmstart(%d): head %x tail %x outqcc %d\n",
985: UNIT(tp->t_dev), head, tail, tp->t_outq.c_cc);
986: #endif
987: out:
988: #ifdef IOSTATS
989: dsp->xchars += tch;
990: if (tch <= DCMXBSIZE)
991: dsp->xsilo[tch]++;
992: else
993: dsp->xsilo[DCMXBSIZE+1]++;
994: #endif
995: splx(s);
996: }
997:
998: /*
999: * Stop output on a line.
1000: */
1001: dcmstop(tp, flag)
1002: register struct tty *tp;
1003: {
1004: int s;
1005:
1006: s = spltty();
1007: if (tp->t_state & TS_BUSY) {
1008: /* XXX is there some way to safely stop transmission? */
1009: if ((tp->t_state&TS_TTSTOP) == 0)
1010: tp->t_state |= TS_FLUSH;
1011: }
1012: splx(s);
1013: }
1014:
1015: /*
1016: * Modem control
1017: */
1018: dcmmctl(dev, bits, how)
1019: dev_t dev;
1020: int bits, how;
1021: {
1022: register struct dcmdevice *dcm;
1023: int s, unit, brd, hit = 0;
1024:
1025: unit = UNIT(dev);
1026: #ifdef DEBUG
1027: if (dcmdebug & DDB_MODEM)
1028: printf("dcmmctl(%d) unit %d bits 0x%x how %x\n",
1029: BOARD(unit), unit, bits, how);
1030: #endif
1031:
1032: brd = BOARD(unit);
1033: dcm = dcm_addr[brd];
1034: s = spltty();
1035: switch (how) {
1036:
1037: case DMSET:
1038: dcm_modem[unit]->mdmout = bits;
1039: hit++;
1040: break;
1041:
1042: case DMBIS:
1043: dcm_modem[unit]->mdmout |= bits;
1044: hit++;
1045: break;
1046:
1047: case DMBIC:
1048: dcm_modem[unit]->mdmout &= ~bits;
1049: hit++;
1050: break;
1051:
1052: case DMGET:
1053: bits = dcm_modem[unit]->mdmin;
1054: if (dcmsoftCAR[brd] & FLAG_STDDCE)
1055: bits = hp2dce_in(bits);
1056: break;
1057: }
1058: if (hit) {
1059: SEM_LOCK(dcm);
1060: dcm->dcm_modemchng |= 1<<(unit & 3);
1061: dcm->dcm_cr |= CR_MODM;
1062: SEM_UNLOCK(dcm);
1063: DELAY(10); /* delay until done */
1064: (void) splx(s);
1065: }
1066: return (bits);
1067: }
1068:
1069: /*
1070: * Set board to either interrupt per-character or at a fixed interval.
1071: */
1072: dcmsetischeme(brd, flags)
1073: int brd, flags;
1074: {
1075: register struct dcmdevice *dcm = dcm_addr[brd];
1076: register struct dcmischeme *dis = &dcmischeme[brd];
1077: register int i;
1078: u_char mask;
1079: int perchar = flags & DIS_PERCHAR;
1080:
1081: #ifdef DEBUG
1082: if (dcmdebug & DDB_INTSCHM)
1083: printf("dcmsetischeme(%d, %d): cur %d, ints %d, chars %d\n",
1084: brd, perchar, dis->dis_perchar,
1085: dis->dis_intr, dis->dis_char);
1086: if ((flags & DIS_RESET) == 0 && perchar == dis->dis_perchar) {
1087: printf("dcmsetischeme(%d): redundent request %d\n",
1088: brd, perchar);
1089: return;
1090: }
1091: #endif
1092: /*
1093: * If perchar is non-zero, we enable interrupts on all characters
1094: * otherwise we disable perchar interrupts and use periodic
1095: * polling interrupts.
1096: */
1097: dis->dis_perchar = perchar;
1098: mask = perchar ? 0xf : 0x0;
1099: for (i = 0; i < 256; i++)
1100: dcm->dcm_bmap[i].data_data = mask;
1101: /*
1102: * Don't slow down tandem mode, interrupt on flow control
1103: * chars for any port on the board.
1104: */
1105: if (!perchar) {
1106: register struct tty *tp = &dcm_tty[MKUNIT(brd, 0)];
1107: int c;
1108:
1109: for (i = 0; i < 4; i++, tp++) {
1110: if ((c = tp->t_cc[VSTART]) != _POSIX_VDISABLE)
1111: dcm->dcm_bmap[c].data_data |= (1 << i);
1112: if ((c = tp->t_cc[VSTOP]) != _POSIX_VDISABLE)
1113: dcm->dcm_bmap[c].data_data |= (1 << i);
1114: }
1115: }
1116: /*
1117: * Board starts with timer disabled so if first call is to
1118: * set perchar mode then we don't want to toggle the timer.
1119: */
1120: if (flags == (DIS_RESET|DIS_PERCHAR))
1121: return;
1122: /*
1123: * Toggle card 16.7ms interrupts (we first make sure that card
1124: * has cleared the bit so it will see the toggle).
1125: */
1126: while (dcm->dcm_cr & CR_TIMER)
1127: ;
1128: SEM_LOCK(dcm);
1129: dcm->dcm_cr |= CR_TIMER;
1130: SEM_UNLOCK(dcm);
1131: }
1132:
1133: /*
1134: * Following are all routines needed for DCM to act as console
1135: */
1136: #include "../hp300/cons.h"
1137:
1138: dcmcnprobe(cp)
1139: struct consdev *cp;
1140: {
1141: register struct hp_hw *hw;
1142: int unit;
1143:
1144: /* locate the major number */
1145: for (dcmmajor = 0; dcmmajor < nchrdev; dcmmajor++)
1146: if (cdevsw[dcmmajor].d_open == dcmopen)
1147: break;
1148:
1149: /*
1150: * Implicitly assigns the lowest select code DCM card found to be
1151: * logical unit 0 (actually CONUNIT). If your config file does
1152: * anything different, you're screwed.
1153: */
1154: for (hw = sc_table; hw->hw_type; hw++)
1155: if (HW_ISDEV(hw, D_COMMDCM) && !badaddr((short *)hw->hw_kva))
1156: break;
1157: if (!HW_ISDEV(hw, D_COMMDCM)) {
1158: cp->cn_pri = CN_DEAD;
1159: return;
1160: }
1161: unit = CONUNIT;
1162: dcm_addr[BOARD(CONUNIT)] = (struct dcmdevice *)hw->hw_kva;
1163:
1164: /* initialize required fields */
1165: cp->cn_dev = makedev(dcmmajor, unit);
1166: cp->cn_tp = &dcm_tty[unit];
1167: switch (dcm_addr[BOARD(unit)]->dcm_rsid) {
1168: case DCMID:
1169: cp->cn_pri = CN_NORMAL;
1170: break;
1171: case DCMID|DCMCON:
1172: cp->cn_pri = CN_REMOTE;
1173: break;
1174: default:
1175: cp->cn_pri = CN_DEAD;
1176: return;
1177: }
1178: /*
1179: * If dcmconsole is initialized, raise our priority.
1180: */
1181: if (dcmconsole == UNIT(unit))
1182: cp->cn_pri = CN_REMOTE;
1183: #ifdef KGDB_CHEAT
1184: /*
1185: * This doesn't currently work, at least not with ite consoles;
1186: * the console hasn't been initialized yet.
1187: */
1188: if (major(kgdb_dev) == dcmmajor && BOARD(kgdb_dev) == BOARD(unit)) {
1189: (void) dcminit(kgdb_dev, kgdb_rate);
1190: if (kgdb_debug_init) {
1191: /*
1192: * We assume that console is ready for us...
1193: * this assumes that a dca or ite console
1194: * has been selected already and will init
1195: * on the first putc.
1196: */
1197: printf("dcm%d: ", UNIT(kgdb_dev));
1198: kgdb_connect(1);
1199: }
1200: }
1201: #endif
1202: }
1203:
1204: dcmcninit(cp)
1205: struct consdev *cp;
1206: {
1207: dcminit(cp->cn_dev, dcmdefaultrate);
1208: dcmconsinit = 1;
1209: dcmconsole = UNIT(cp->cn_dev);
1210: }
1211:
1212: dcminit(dev, rate)
1213: dev_t dev;
1214: int rate;
1215: {
1216: register struct dcmdevice *dcm = dcm_addr[BOARD(dev)];
1217: int s, mode, port;
1218:
1219: port = PORT(dev);
1220: mode = LC_8BITS | LC_1STOP;
1221: s = splhigh();
1222: /*
1223: * Wait for transmitter buffer to empty.
1224: */
1225: while (dcm->dcm_thead[port].ptr != dcm->dcm_ttail[port].ptr)
1226: DELAY(DCM_USPERCH(rate));
1227: /*
1228: * Make changes known to hardware.
1229: */
1230: dcm->dcm_data[port].dcm_baud = ttspeedtab(rate, dcmspeedtab);
1231: dcm->dcm_data[port].dcm_conf = mode;
1232: SEM_LOCK(dcm);
1233: dcm->dcm_cmdtab[port].dcm_data |= CT_CON;
1234: dcm->dcm_cr |= (1 << port);
1235: SEM_UNLOCK(dcm);
1236: /*
1237: * Delay for config change to take place. Weighted by baud.
1238: * XXX why do we do this?
1239: */
1240: DELAY(16 * DCM_USPERCH(rate));
1241: splx(s);
1242: }
1243:
1244: dcmcngetc(dev)
1245: dev_t dev;
1246: {
1247: register struct dcmdevice *dcm = dcm_addr[BOARD(dev)];
1248: register struct dcmrfifo *fifo;
1249: register struct dcmpreg *pp;
1250: register unsigned head;
1251: int s, c, stat, port;
1252:
1253: port = PORT(dev);
1254: pp = dcm_preg(dcm, port);
1255: s = splhigh();
1256: head = pp->r_head & RX_MASK;
1257: fifo = &dcm->dcm_rfifos[3-port][head>>1];
1258: while (head == (pp->r_tail & RX_MASK))
1259: ;
1260: /*
1261: * If board interrupts are enabled, just let our received char
1262: * interrupt through in case some other port on the board was
1263: * busy. Otherwise we must clear the interrupt.
1264: */
1265: SEM_LOCK(dcm);
1266: if ((dcm->dcm_ic & IC_IE) == 0)
1267: stat = dcm->dcm_iir;
1268: SEM_UNLOCK(dcm);
1269: c = fifo->data_char;
1270: stat = fifo->data_stat;
1271: pp->r_head = (head + 2) & RX_MASK;
1272: splx(s);
1273: return (c);
1274: }
1275:
1276: /*
1277: * Console kernel output character routine.
1278: */
1279: dcmcnputc(dev, c)
1280: dev_t dev;
1281: int c;
1282: {
1283: register struct dcmdevice *dcm = dcm_addr[BOARD(dev)];
1284: register struct dcmpreg *pp;
1285: unsigned tail;
1286: int s, port, stat;
1287:
1288: port = PORT(dev);
1289: pp = dcm_preg(dcm, port);
1290: s = splhigh();
1291: #ifdef KGDB
1292: if (dev != kgdb_dev)
1293: #endif
1294: if (dcmconsinit == 0) {
1295: (void) dcminit(dev, dcmdefaultrate);
1296: dcmconsinit = 1;
1297: }
1298: tail = pp->t_tail & TX_MASK;
1299: while (tail != (pp->t_head & TX_MASK))
1300: ;
1301: dcm->dcm_tfifos[3-port][tail].data_char = c;
1302: pp->t_tail = tail = (tail + 1) & TX_MASK;
1303: SEM_LOCK(dcm);
1304: dcm->dcm_cmdtab[port].dcm_data |= CT_TX;
1305: dcm->dcm_cr |= (1 << port);
1306: SEM_UNLOCK(dcm);
1307: while (tail != (pp->t_head & TX_MASK))
1308: ;
1309: /*
1310: * If board interrupts are enabled, just let our completion
1311: * interrupt through in case some other port on the board
1312: * was busy. Otherwise we must clear the interrupt.
1313: */
1314: if ((dcm->dcm_ic & IC_IE) == 0) {
1315: SEM_LOCK(dcm);
1316: stat = dcm->dcm_iir;
1317: SEM_UNLOCK(dcm);
1318: }
1319: splx(s);
1320: }
1321: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.