![[BACK]](/icons/back.gif){kind=icon}
Return to bugtty.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / mvmeppc / dev|
Return to bugtty.c CVS log | Up to [local] / sys / arch / mvmeppc / dev |
1.1 nbrk 1: /* $OpenBSD: bugtty.c,v 1.10 2004/05/14 20:38:32 miod Exp $ */
2:
3: /* Copyright (c) 1998 Steve Murphree, Jr.
4: * Copyright (c) 1995 Dale Rahn.
5: * All rights reserved.
6: *
7: * Redistribution and use in source and binary forms, with or without
8: * modification, are permitted provided that the following conditions
9: * are met:
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: * 3. The name of the author may not be used to endorse or promote products
16: * derived from this software without specific prior written permission.
17: *
18: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28: */
29:
30: #include <sys/param.h>
31: #include <sys/systm.h>
32: #include <sys/ioctl.h>
33: #include <sys/device.h>
34: #include <sys/tty.h>
35: #include <sys/proc.h>
36: #include <sys/uio.h>
37: #include <sys/queue.h>
38:
39: #include <machine/autoconf.h>
40: #include <machine/bugio.h>
41: #include <machine/conf.h>
42: #include <machine/cpu.h>
43:
44: #include <dev/cons.h>
45:
46: #include "bugtty.h"
47:
48: int bugttymatch(struct device *parent, void *self, void *aux);
49: void bugttyattach(struct device *parent, struct device *self, void *aux);
50:
51: struct cfattach bugtty_ca = {
52: sizeof(struct device), bugttymatch, bugttyattach
53: };
54:
55: struct cfdriver bugtty_cd = {
56: NULL, "bugtty", DV_TTY
57: };
58:
59: /* prototypes */
60: cons_decl(bugtty);
61: cdev_decl(bugtty);
62:
63: int bugttymctl(dev_t dev, int bits, int how);
64: int bugttyparam(struct tty *tp, struct termios *tm);
65: void bugtty_chkinput(void);
66:
67: #define DIALOUT(x) ((x) & 0x80)
68: #define SWFLAGS(dev) (bugttyswflags | (DIALOUT(dev) ? TIOCFLAG_SOFTCAR : 0))
69:
70: #define BUGBUF 80
71: char bugtty_ibuffer[BUGBUF+1];
72: volatile char *pinchar = bugtty_ibuffer;
73: char bug_obuffer[BUGBUF+1];
74:
75: #define BUGTTYS 4
76: struct tty *bugtty_tty[BUGTTYS];
77:
78: int
79: bugttymatch(parent, self, aux)
80: struct device *parent;
81: void *self;
82: void *aux;
83: {
84: struct confargs *ca = aux;
85:
86: if (strcmp(ca->ca_name, bugtty_cd.cd_name) != 0)
87: return (0);
88:
89: return (1);
90: }
91:
92: void
93: bugttyattach(parent, self, aux)
94: struct device *parent;
95: struct device *self;
96: void *aux;
97: {
98: printf(": fallback console\n");
99: }
100:
101: #define BUGTTYUNIT(x) ((x) & (0x7f))
102: void bugttyoutput(struct tty *tp);
103:
104: int bugttydefaultrate = TTYDEF_SPEED;
105: int bugttyswflags;
106:
107: struct tty *
108: bugttytty(dev)
109: dev_t dev;
110: {
111: int unit;
112: unit = BUGTTYUNIT(dev);
113: if (unit >= BUGTTYS) {
114: return (NULL);
115: }
116: return bugtty_tty[unit];
117: }
118:
119: int
120: bugttymctl(dev, bits, how)
121: dev_t dev;
122: int bits, how;
123: {
124: int s;
125:
126: /*printf("mctl: dev %x, bits %x, how %x,",dev, bits, how);*/
127:
128: /* settings are currently ignored */
129: s = spltty();
130: switch (how) {
131: case DMSET:
132: break;
133: case DMBIC:
134: break;
135: case DMBIS:
136: break;
137: case DMGET:
138: break;
139: }
140: splx(s);
141:
142: bits = 0;
143: /* proper defaults? */
144: bits |= TIOCM_DTR;
145: bits |= TIOCM_RTS;
146: bits |= TIOCM_CTS;
147: bits |= TIOCM_CD;
148: /* bits |= TIOCM_RI; */
149: bits |= TIOCM_DSR;
150:
151: /* printf("retbits %x\n", bits); */
152: return (bits);
153: }
154:
155: int
156: bugttyopen(dev, flag, mode, p)
157: dev_t dev;
158: int flag, mode;
159: struct proc *p;
160: {
161: int s, unit = BUGTTYUNIT(dev);
162: struct tty *tp;
163:
164: s = spltty();
165: if (bugtty_tty[unit]) {
166: tp = bugtty_tty[unit];
167: } else {
168: tp = bugtty_tty[unit] = ttymalloc();
169: }
170: tp->t_oproc = bugttyoutput;
171: tp->t_param = NULL;
172: tp->t_dev = dev;
173:
174: if ((tp->t_state & TS_ISOPEN) == 0) {
175: tp->t_state |= TS_WOPEN;
176: ttychars(tp);
177: if (tp->t_ispeed == 0) {
178: /*
179: * only when cleared do we reset to defaults.
180: */
181: tp->t_iflag = TTYDEF_IFLAG;
182: tp->t_oflag = TTYDEF_OFLAG;
183: tp->t_cflag = TTYDEF_CFLAG;
184: tp->t_lflag = TTYDEF_LFLAG;
185: tp->t_ispeed = tp->t_ospeed = bugttydefaultrate;
186: }
187: /* bugtty does not have carrier */
188: tp->t_cflag |= CLOCAL;
189: /*
190: * do these all the time
191: */
192: if (bugttyswflags & TIOCFLAG_CLOCAL)
193: tp->t_cflag |= CLOCAL;
194: if (bugttyswflags & TIOCFLAG_CRTSCTS)
195: tp->t_cflag |= CRTSCTS;
196: if (bugttyswflags & TIOCFLAG_MDMBUF)
197: tp->t_cflag |= MDMBUF;
198: bugttyparam(tp, &tp->t_termios);
199: ttsetwater(tp);
200:
201: (void)bugttymctl(dev, TIOCM_DTR | TIOCM_RTS, DMSET);
202: /*
203: if ((SWFLAGS(dev) & TIOCFLAG_SOFTCAR) ||
204: (bugttymctl(dev, 0, DMGET) & TIOCM_CD))
205: tp->t_state |= TS_CARR_ON;
206: else
207: tp->t_state &= ~TS_CARR_ON;
208: */
209: tp->t_state |= TS_CARR_ON;
210: } else if (tp->t_state & TS_XCLUDE && p->p_ucred->cr_uid != 0) {
211: splx(s);
212: return (EBUSY);
213: }
214:
215: /*
216: * if NONBLOCK requested, ignore carrier
217: */
218: /*
219: if (flag & O_NONBLOCK)
220: goto done;
221: */
222:
223: splx(s);
224: /*
225: * Reset the tty pointer, as there could have been a dialout
226: * use of the tty with a dialin open waiting.
227: */
228: tp->t_dev = dev;
229: return ((*linesw[tp->t_line].l_open)(dev, tp));
230: }
231:
232: int
233: bugttyparam(tp, tm)
234: struct tty *tp;
235: struct termios *tm;
236: {
237: return (0);
238: }
239:
240: void
241: bugttyoutput(tp)
242: struct tty *tp;
243: {
244: int cc, s, cnt;
245:
246: /* only supports one unit */
247:
248: if ((tp->t_state & TS_ISOPEN) == 0)
249: return;
250:
251: s = spltty();
252: cc = tp->t_outq.c_cc;
253: while (cc > 0) {
254: cnt = min(BUGBUF, cc);
255: cnt = q_to_b(&tp->t_outq, bug_obuffer, cnt);
256: mvmeprom_outstr(bug_obuffer, &bug_obuffer[cnt]);
257: cc -= cnt;
258: }
259: splx(s);
260: }
261:
262: int
263: bugttyclose(dev, flag, mode, p)
264: dev_t dev;
265: int flag, mode;
266: struct proc *p;
267: {
268: int unit = BUGTTYUNIT(dev);
269: struct tty *tp = bugtty_tty[unit];
270:
271: (*linesw[tp->t_line].l_close)(tp, flag);
272:
273: ttyclose(tp);
274: #if 0
275: bugtty_tty[unit] = NULL;
276: #endif
277: return (0);
278: }
279:
280: int
281: bugttyread(dev, uio, flag)
282: dev_t dev;
283: struct uio *uio;
284: int flag;
285: {
286: struct tty *tp;
287:
288: if ((tp = bugtty_tty[BUGTTYUNIT(dev)]) == NULL)
289: return (ENXIO);
290: return ((*linesw[tp->t_line].l_read)(tp, uio, flag));
291: }
292:
293: /* only to be called at splclk() */
294: void
295: bugtty_chkinput()
296: {
297: struct tty *tp;
298:
299: tp = bugtty_tty[0]; /* assumes console on the first port... */
300: if (tp == NULL)
301: return;
302:
303: while (mvmeprom_instat() != 0) {
304: u_char c = mvmeprom_getchar() & 0xff;
305: (*linesw[tp->t_line].l_rint)(c, tp);
306: }
307: }
308:
309: int
310: bugttywrite(dev, uio, flag)
311: dev_t dev;
312: struct uio *uio;
313: int flag;
314: {
315: #if 0
316: /* bypass tty output routines. */
317: int i, cnt, s;
318: int oldoff;
319:
320: s = spltty();
321: oldoff = uio->uio_offset;
322: do {
323: uiomove(bug_obuffer, BUGBUF, uio);
324: bugoutstr(bug_obuffer, &bug_obuffer[uio->uio_offset - oldoff]);
325: oldoff = uio->uio_offset;
326: } while (uio->uio_resid != 0);
327: splx(s);
328:
329: return (0);
330: #else
331: struct tty *tp;
332: if((tp = bugtty_tty[BUGTTYUNIT(dev)]) == NULL)
333: return (ENXIO);
334: return ((*linesw[tp->t_line].l_write)(tp, uio, flag));
335: #endif
336: }
337:
338: int
339: bugttyioctl(dev, cmd, data, flag, p)
340: dev_t dev;
341: u_long cmd;
342: caddr_t data;
343: int flag;
344: struct proc *p;
345: {
346: int unit = BUGTTYUNIT(dev);
347: struct tty *tp = bugtty_tty[unit];
348: int error;
349:
350: if (!tp)
351: return (ENXIO);
352:
353: error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p);
354: if (error >= 0)
355: return (error);
356:
357: error = ttioctl(tp, cmd, data, flag, p);
358: if (error >= 0)
359: return (error);
360:
361: switch (cmd) {
362: case TIOCSBRK:
363: /* */
364: break;
365:
366: case TIOCCBRK:
367: /* */
368: break;
369:
370: case TIOCSDTR:
371: (void) bugttymctl(dev, TIOCM_DTR | TIOCM_RTS, DMBIS);
372: break;
373:
374: case TIOCCDTR:
375: (void) bugttymctl(dev, TIOCM_DTR | TIOCM_RTS, DMBIC);
376: break;
377:
378: case TIOCMSET:
379: (void) bugttymctl(dev, *(int *) data, DMSET);
380: break;
381:
382: case TIOCMBIS:
383: (void) bugttymctl(dev, *(int *) data, DMBIS);
384: break;
385:
386: case TIOCMBIC:
387: (void) bugttymctl(dev, *(int *) data, DMBIC);
388: break;
389:
390: case TIOCMGET:
391: *(int *)data = bugttymctl(dev, 0, DMGET);
392: break;
393: case TIOCGFLAGS:
394: *(int *)data = SWFLAGS(dev);
395: break;
396: case TIOCSFLAGS:
397: error = suser(p, 0);
398: if (error != 0)
399: return (EPERM);
400:
401: bugttyswflags = *(int *)data;
402: bugttyswflags &= /* only allow valid flags */
403: (TIOCFLAG_SOFTCAR | TIOCFLAG_CLOCAL | TIOCFLAG_CRTSCTS);
404: break;
405: default:
406: return (ENOTTY);
407: }
408:
409: return (0);
410: }
411:
412: int
413: bugttystop(tp, flag)
414: struct tty *tp;
415: int flag;
416: {
417: int s;
418:
419: s = spltty();
420: if (tp->t_state & TS_BUSY) {
421: if ((tp->t_state & TS_TTSTOP) == 0)
422: tp->t_state |= TS_FLUSH;
423: }
424: splx(s);
425: return (0);
426: }
427:
428: /*
429: * bugtty is the last possible choice for a console device.
430: */
431: void
432: bugttycnprobe(cp)
433: struct consdev *cp;
434: {
435: int maj;
436:
437: /* locate the major number */
438: for (maj = 0; maj < nchrdev; maj++)
439: if (cdevsw[maj].d_open == bugttyopen)
440: break;
441:
442: cp->cn_dev = makedev(maj, 0);
443: cp->cn_pri = CN_NORMAL;
444: }
445:
446: void
447: bugttycninit(cp)
448: struct consdev *cp;
449: {
450: /* Nothing to do */
451: }
452:
453: int
454: bugttycngetc(dev)
455: dev_t dev;
456: {
457: return (mvmeprom_getchar());
458: }
459:
460: void
461: bugttycnputc(dev, c)
462: dev_t dev;
463: char c;
464: {
465: mvmeprom_outchar(c);
466: }