Annotation of sys/arch/sparc64/dev/z8530kbd.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: z8530kbd.c,v 1.19 2007/05/25 21:27:15 krw Exp $ */
2: /* $NetBSD: z8530tty.c,v 1.77 2001/05/30 15:24:24 lukem Exp $ */
3:
4: /*-
5: * Copyright (c) 1993, 1994, 1995, 1996, 1997, 1998, 1999
6: * Charles M. Hannum. All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. All advertising materials mentioning features or use of this software
17: * must display the following acknowledgement:
18: * This product includes software developed by Charles M. Hannum.
19: * 4. The name of the author may not be used to endorse or promote products
20: * derived from this software without specific prior written permission.
21: *
22: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
23: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
26: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
27: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
31: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32: */
33:
34: /*
35: * Copyright (c) 1994 Gordon W. Ross
36: * Copyright (c) 1992, 1993
37: * The Regents of the University of California. All rights reserved.
38: *
39: * This software was developed by the Computer Systems Engineering group
40: * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
41: * contributed to Berkeley.
42: *
43: * All advertising materials mentioning features or use of this software
44: * must display the following acknowledgement:
45: * This product includes software developed by the University of
46: * California, Lawrence Berkeley Laboratory.
47: *
48: * Redistribution and use in source and binary forms, with or without
49: * modification, are permitted provided that the following conditions
50: * are met:
51: * 1. Redistributions of source code must retain the above copyright
52: * notice, this list of conditions and the following disclaimer.
53: * 2. Redistributions in binary form must reproduce the above copyright
54: * notice, this list of conditions and the following disclaimer in the
55: * documentation and/or other materials provided with the distribution.
56: * 3. Neither the name of the University nor the names of its contributors
57: * may be used to endorse or promote products derived from this software
58: * without specific prior written permission.
59: *
60: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
61: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
62: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
63: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
64: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
65: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
66: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
67: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
68: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
69: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
70: * SUCH DAMAGE.
71: *
72: * @(#)zs.c 8.1 (Berkeley) 7/19/93
73: */
74:
75: /*
76: * Zilog Z8530 Dual UART driver (tty interface)
77: *
78: * This is the "slave" driver that will be attached to
79: * the "zsc" driver for plain "tty" async. serial lines.
80: *
81: * Credits, history:
82: *
83: * The original version of this code was the sparc/dev/zs.c driver
84: * as distributed with the Berkeley 4.4 Lite release. Since then,
85: * Gordon Ross reorganized the code into the current parent/child
86: * driver scheme, separating the Sun keyboard and mouse support
87: * into independent child drivers.
88: *
89: * RTS/CTS flow-control support was a collaboration of:
90: * Gordon Ross <gwr@netbsd.org>,
91: * Bill Studenmund <wrstuden@loki.stanford.edu>
92: * Ian Dall <Ian.Dall@dsto.defence.gov.au>
93: *
94: * The driver was massively overhauled in November 1997 by Charles Hannum,
95: * fixing *many* bugs, and substantially improving performance.
96: */
97:
98: #include <sys/param.h>
99: #include <sys/systm.h>
100: #include <sys/proc.h>
101: #include <sys/device.h>
102: #include <sys/conf.h>
103: #include <sys/file.h>
104: #include <sys/ioctl.h>
105: #include <sys/malloc.h>
106: #include <sys/tty.h>
107: #include <sys/time.h>
108: #include <sys/kernel.h>
109: #include <sys/syslog.h>
110:
111: #include <machine/autoconf.h>
112:
113: #include <dev/wscons/wsconsio.h>
114: #include <dev/wscons/wskbdvar.h>
115:
116: #include <dev/sun/sunkbdreg.h>
117: #include <dev/sun/sunkbdvar.h>
118:
119: #include <sparc64/dev/z8530reg.h>
120: #include <machine/z8530var.h>
121:
122: #include <dev/cons.h>
123:
124: /*
125: * How many input characters we can buffer.
126: * The port-specific var.h may override this.
127: * Note: must be a power of two!
128: */
129: #ifndef ZSKBD_RING_SIZE
130: #define ZSKBD_RING_SIZE 2048
131: #endif
132:
133: struct cfdriver zskbd_cd = {
134: NULL, "zskbd", DV_TTY
135: };
136:
137: /*
138: * Make this an option variable one can patch.
139: * But be warned: this must be a power of 2!
140: */
141: u_int zskbd_rbuf_size = ZSKBD_RING_SIZE;
142:
143: /* Stop input when 3/4 of the ring is full; restart when only 1/4 is full. */
144: u_int zskbd_rbuf_hiwat = (ZSKBD_RING_SIZE * 1) / 4;
145: u_int zskbd_rbuf_lowat = (ZSKBD_RING_SIZE * 3) / 4;
146:
147: struct zskbd_softc {
148: struct sunkbd_softc sc_base;
149:
150: struct zs_chanstate *zst_cs;
151:
152: struct timeout zst_diag_ch;
153:
154: u_int zst_overflows,
155: zst_floods,
156: zst_errors;
157:
158: int zst_hwflags, /* see z8530var.h */
159: zst_swflags; /* TIOCFLAG_SOFTCAR, ... <ttycom.h> */
160:
161: u_int zst_r_hiwat,
162: zst_r_lowat;
163: u_char *volatile zst_rbget,
164: *volatile zst_rbput;
165: volatile u_int zst_rbavail;
166: u_char *zst_rbuf,
167: *zst_ebuf;
168:
169: /*
170: * The transmit byte count and address are used for pseudo-DMA
171: * output in the hardware interrupt code. PDMA can be suspended
172: * to get pending changes done; heldtbc is used for this. It can
173: * also be stopped for ^S; this sets TS_TTSTOP in tp->t_state.
174: */
175: u_char *zst_tba; /* transmit buffer address */
176: u_int zst_tbc, /* transmit byte count */
177: zst_heldtbc; /* held tbc while xmission stopped */
178:
179: u_char zst_tbuf[ZSKBD_RING_SIZE];
180: u_char *zst_tbeg, *zst_tend, *zst_tbp;
181:
182: /* Flags to communicate with zskbd_softint() */
183: volatile u_char zst_rx_flags, /* receiver blocked */
184: #define RX_TTY_BLOCKED 0x01
185: #define RX_TTY_OVERFLOWED 0x02
186: #define RX_IBUF_BLOCKED 0x04
187: #define RX_IBUF_OVERFLOWED 0x08
188: #define RX_ANY_BLOCK 0x0f
189: zst_tx_busy, /* working on an output chunk */
190: zst_tx_done, /* done with one output chunk */
191: zst_tx_stopped, /* H/W level stop (lost CTS) */
192: zst_st_check, /* got a status interrupt */
193: zst_rx_ready;
194:
195: /* PPS signal on DCD, with or without inkernel clock disciplining */
196: u_char zst_ppsmask; /* pps signal mask */
197: u_char zst_ppsassert; /* pps leading edge */
198: u_char zst_ppsclear; /* pps trailing edge */
199: };
200:
201: /* Definition of the driver for autoconfig. */
202: static int zskbd_match(struct device *, void *, void *);
203: static void zskbd_attach(struct device *, struct device *, void *);
204:
205: struct cfattach zskbd_ca = {
206: sizeof(struct zskbd_softc), zskbd_match, zskbd_attach
207: };
208:
209: struct zsops zsops_kbd;
210:
211: static void zs_modem(struct zskbd_softc *, int);
212: static void zs_hwiflow(struct zskbd_softc *);
213: static void zs_maskintr(struct zskbd_softc *);
214:
215: struct zskbd_softc *zskbd_device_lookup(struct cfdriver *, int);
216:
217: /* Low-level routines. */
218: static void zskbd_rxint(struct zs_chanstate *);
219: static void zskbd_stint(struct zs_chanstate *, int);
220: static void zskbd_txint(struct zs_chanstate *);
221: static void zskbd_softint(struct zs_chanstate *);
222: static void zskbd_diag(void *);
223:
224: int zskbd_init(struct zskbd_softc *);
225: void zskbd_putc(struct zskbd_softc *, u_int8_t);
226: void zskbd_raw(struct zskbd_softc *, u_int8_t);
227:
228: /* wskbd glue */
229: void zskbd_cngetc(void *, u_int *, int *);
230: void zskbd_cnpollc(void *, int);
231:
232: void zsstart_tx(struct zskbd_softc *);
233: int zsenqueue_tx(void *, u_int8_t *, u_int);
234:
235: struct wskbd_consops zskbd_consops = {
236: zskbd_cngetc,
237: zskbd_cnpollc
238: };
239:
240: #define ZSKBDUNIT(x) (minor(x) & 0x7ffff)
241:
242: struct zskbd_softc *
243: zskbd_device_lookup(cf, unit)
244: struct cfdriver *cf;
245: int unit;
246: {
247: return (struct zskbd_softc *)device_lookup(cf, unit);
248: }
249:
250: /*
251: * zskbd_match: how is this zs channel configured?
252: */
253: int
254: zskbd_match(parent, vcf, aux)
255: struct device *parent;
256: void *vcf;
257: void *aux;
258: {
259: struct cfdata *cf = vcf;
260: struct zsc_attach_args *args = aux;
261: int ret;
262:
263: /* If we're not looking for a keyboard, just exit */
264: if (strcmp(args->type, "keyboard") != 0)
265: return (0);
266:
267: ret = 10;
268:
269: /* Exact match is better than wildcard. */
270: if (cf->cf_loc[ZSCCF_CHANNEL] == args->channel)
271: ret += 2;
272:
273: /* This driver accepts wildcard. */
274: if (cf->cf_loc[ZSCCF_CHANNEL] == ZSCCF_CHANNEL_DEFAULT)
275: ret += 1;
276:
277: return (ret);
278: }
279:
280: void
281: zskbd_attach(parent, self, aux)
282: struct device *parent, *self;
283: void *aux;
284:
285: {
286: struct zsc_softc *zsc = (void *)parent;
287: struct zskbd_softc *zst = (void *)self;
288: struct sunkbd_softc *ss = (void *)self;
289: struct cfdata *cf = self->dv_cfdata;
290: struct zsc_attach_args *args = aux;
291: struct wskbddev_attach_args a;
292: struct zs_chanstate *cs;
293: int channel, s, tty_unit, console = 0;
294: dev_t dev;
295:
296: ss->sc_sendcmd = zsenqueue_tx;
297: timeout_set(&ss->sc_bellto, sunkbd_bellstop, zst);
298:
299: timeout_set(&zst->zst_diag_ch, zskbd_diag, zst);
300:
301: zst->zst_tbp = zst->zst_tba = zst->zst_tbeg = zst->zst_tbuf;
302: zst->zst_tend = zst->zst_tbeg + ZSKBD_RING_SIZE;
303:
304: tty_unit = ss->sc_dev.dv_unit;
305: channel = args->channel;
306: cs = zsc->zsc_cs[channel];
307: cs->cs_private = zst;
308: cs->cs_ops = &zsops_kbd;
309:
310: zst->zst_cs = cs;
311: zst->zst_swflags = cf->cf_flags; /* softcar, etc. */
312: zst->zst_hwflags = args->hwflags;
313: dev = makedev(zs_major, tty_unit);
314:
315: if (zst->zst_swflags)
316: printf(" flags 0x%x", zst->zst_swflags);
317:
318: /*
319: * Check whether we serve as a console device.
320: * XXX - split console input/output channels aren't
321: * supported yet on /dev/console
322: */
323: if ((zst->zst_hwflags & ZS_HWFLAG_CONSOLE_INPUT) != 0) {
324: if ((args->hwflags & ZS_HWFLAG_USE_CONSDEV) != 0) {
325: args->consdev->cn_dev = dev;
326: cn_tab->cn_pollc = wskbd_cnpollc;
327: cn_tab->cn_getc = wskbd_cngetc;
328: }
329: cn_tab->cn_dev = dev;
330: console = 1;
331: }
332:
333: zst->zst_rbuf = malloc(zskbd_rbuf_size << 1, M_DEVBUF, M_WAITOK);
334: zst->zst_ebuf = zst->zst_rbuf + (zskbd_rbuf_size << 1);
335: /* Disable the high water mark. */
336: zst->zst_r_hiwat = 0;
337: zst->zst_r_lowat = 0;
338: zst->zst_rbget = zst->zst_rbput = zst->zst_rbuf;
339: zst->zst_rbavail = zskbd_rbuf_size;
340:
341: /* if there are no enable/disable functions, assume the device
342: is always enabled */
343: if (!cs->enable)
344: cs->enabled = 1;
345:
346: /*
347: * Hardware init
348: */
349: if (ISSET(zst->zst_hwflags, ZS_HWFLAG_CONSOLE)) {
350: /* Call zsparam similar to open. */
351:
352: /* Wait a while for previous console output to complete */
353: DELAY(10000);
354: } else if (!ISSET(zst->zst_hwflags, ZS_HWFLAG_NORESET)) {
355: /* Not the console; may need reset. */
356: int reset;
357:
358: reset = (channel == 0) ? ZSWR9_A_RESET : ZSWR9_B_RESET;
359: s = splzs();
360: zs_write_reg(cs, 9, reset);
361: splx(s);
362: }
363:
364: /*
365: * Probe for a keyboard.
366: * If one is found, turn on receiver and status interrupts.
367: * We defer the actual write of the register to zsparam(),
368: * but we must make sure status interrupts are turned on by
369: * the time zsparam() reads the initial rr0 state.
370: */
371: if (zskbd_init(zst)) {
372: SET(cs->cs_preg[1], ZSWR1_RIE | ZSWR1_SIE);
373: zs_write_reg(cs, 1, cs->cs_creg[1]);
374:
375: /* Make sure DTR is on now. */
376: s = splzs();
377: zs_modem(zst, 1);
378: splx(s);
379: } else {
380: /* Will raise DTR in open. */
381: s = splzs();
382: zs_modem(zst, 0);
383: splx(s);
384:
385: return;
386: }
387:
388: ss->sc_click =
389: strcmp(getpropstring(optionsnode, "keyboard-click?"), "true") == 0;
390: sunkbd_setclick(ss, ss->sc_click);
391:
392: a.console = console;
393: if (ISTYPE5(ss->sc_layout)) {
394: a.keymap = &sunkbd5_keymapdata;
395: #ifndef SUNKBD5_LAYOUT
396: if (ss->sc_layout < MAXSUNLAYOUT &&
397: sunkbd_layouts[ss->sc_layout] != -1)
398: sunkbd5_keymapdata.layout =
399: sunkbd_layouts[ss->sc_layout];
400: #endif
401: } else {
402: a.keymap = &sunkbd_keymapdata;
403: #ifndef SUNKBD_LAYOUT
404: if (ss->sc_layout < MAXSUNLAYOUT &&
405: sunkbd_layouts[ss->sc_layout] != -1)
406: sunkbd_keymapdata.layout =
407: sunkbd_layouts[ss->sc_layout];
408: #endif
409: }
410: a.accessops = &sunkbd_accessops;
411: a.accesscookie = zst;
412:
413: if (console)
414: wskbd_cnattach(&zskbd_consops, zst, a.keymap);
415:
416: ss->sc_wskbddev = config_found(self, &a, wskbddevprint);
417: }
418:
419: int
420: zskbd_init(zst)
421: struct zskbd_softc *zst;
422: {
423: struct sunkbd_softc *ss = (void *)zst;
424: struct zs_chanstate *cs = zst->zst_cs;
425: int s, tries;
426: u_int8_t v3, v4, v5, rr0;
427:
428: /* setup for 1200n81 */
429: if (zs_set_speed(cs, 1200)) { /* set 1200bps */
430: printf(": failed to set baudrate\n");
431: return 0;
432: }
433: if (zs_set_modes(cs, CS8 | CLOCAL)) {
434: printf(": failed to set modes\n");
435: return 0;
436: }
437:
438: s = splzs();
439:
440: zs_maskintr(zst);
441:
442: v3 = cs->cs_preg[3]; /* set 8 bit chars */
443: v5 = cs->cs_preg[5];
444: CLR(v3, ZSWR3_RXSIZE);
445: CLR(v5, ZSWR5_TXSIZE);
446: SET(v3, ZSWR3_RX_8);
447: SET(v5, ZSWR5_TX_8);
448: cs->cs_preg[3] = v3;
449: cs->cs_preg[5] = v5;
450:
451: v4 = cs->cs_preg[4]; /* no parity 1 stop */
452: CLR(v4, ZSWR4_SBMASK | ZSWR4_PARMASK);
453: SET(v4, ZSWR4_ONESB | ZSWR4_EVENP);
454: cs->cs_preg[4] = v4;
455:
456: if (!cs->cs_heldchange) {
457: if (zst->zst_tx_busy) {
458: zst->zst_heldtbc = zst->zst_tbc;
459: zst->zst_tbc = 0;
460: cs->cs_heldchange = 1;
461: } else
462: zs_loadchannelregs(cs);
463: }
464:
465: /*
466: * Hardware flow control is disabled, turn off the buffer water
467: * marks and unblock any soft flow control state. Otherwise, enable
468: * the water marks.
469: */
470: zst->zst_r_hiwat = 0;
471: zst->zst_r_lowat = 0;
472: if (ISSET(zst->zst_rx_flags, RX_TTY_OVERFLOWED)) {
473: CLR(zst->zst_rx_flags, RX_TTY_OVERFLOWED);
474: zst->zst_rx_ready = 1;
475: cs->cs_softreq = 1;
476: }
477: if (ISSET(zst->zst_rx_flags, RX_TTY_BLOCKED|RX_IBUF_BLOCKED)) {
478: CLR(zst->zst_rx_flags, RX_TTY_BLOCKED|RX_IBUF_BLOCKED);
479: zs_hwiflow(zst);
480: }
481:
482: /*
483: * Force a recheck of the hardware carrier and flow control status,
484: * since we may have changed which bits we're looking at.
485: */
486: zskbd_stint(cs, 1);
487:
488: splx(s);
489:
490: /*
491: * Hardware flow control is disabled, unblock any hard flow control
492: * state.
493: */
494: if (zst->zst_tx_stopped) {
495: zst->zst_tx_stopped = 0;
496: zsstart_tx(zst);
497: }
498:
499: zskbd_softint(cs);
500:
501: /* Ok, start the reset sequence... */
502:
503: s = splhigh();
504:
505: for (tries = 5; tries != 0; tries--) {
506: int ltries;
507:
508: ss->sc_leds = 0;
509: ss->sc_layout = -1;
510:
511: /* Send reset request */
512: zskbd_putc(zst, SKBD_CMD_RESET);
513:
514: ltries = 1000;
515: while (--ltries > 0) {
516: rr0 = *cs->cs_reg_csr;
517: if (rr0 & ZSRR0_RX_READY) {
518: sunkbd_raw(ss, *cs->cs_reg_data);
519: if (ss->sc_kbdstate == SKBD_STATE_RESET)
520: break;
521: }
522: DELAY(1000);
523: }
524: if (ltries == 0)
525: continue;
526:
527: /* Wait for reset to finish. */
528: ltries = 1000;
529: while (--ltries > 0) {
530: rr0 = *cs->cs_reg_csr;
531: if (rr0 & ZSRR0_RX_READY) {
532: sunkbd_raw(ss, *cs->cs_reg_data);
533: if (ss->sc_kbdstate == SKBD_STATE_GETKEY)
534: break;
535: }
536: DELAY(1000);
537: }
538: if (ltries == 0)
539: continue;
540:
541:
542: /* Send layout request */
543: zskbd_putc(zst, SKBD_CMD_LAYOUT);
544:
545: ltries = 1000;
546: while (--ltries > 0) {
547: rr0 = *cs->cs_reg_csr;
548: if (rr0 & ZSRR0_RX_READY) {
549: sunkbd_raw(ss, *cs->cs_reg_data);
550: if (ss->sc_layout != -1)
551: break;
552: }
553: DELAY(1000);
554: }
555: if (ltries == 0)
556: continue;
557: break;
558: }
559: if (tries == 0)
560: printf(": no keyboard\n");
561: else
562: printf(": layout %d\n", ss->sc_layout);
563: splx(s);
564:
565: return tries;
566: }
567:
568: void
569: zskbd_putc(zst, c)
570: struct zskbd_softc *zst;
571: u_int8_t c;
572: {
573: u_int8_t rr0;
574: int s;
575:
576: s = splhigh();
577: do {
578: rr0 = *zst->zst_cs->cs_reg_csr;
579: } while ((rr0 & ZSRR0_TX_READY) == 0);
580: *zst->zst_cs->cs_reg_data = c;
581: delay(2);
582: splx(s);
583: }
584:
585: int
586: zsenqueue_tx(v, str, len)
587: void *v;
588: u_int8_t *str;
589: u_int len;
590: {
591: struct zskbd_softc *zst = v;
592: int s;
593: u_int i;
594:
595: s = splzs();
596: if (zst->zst_tbc + len > ZSKBD_RING_SIZE)
597: return (-1);
598: zst->zst_tbc += len;
599: for (i = 0; i < len; i++) {
600: *zst->zst_tbp = str[i];
601: if (++zst->zst_tbp == zst->zst_tend)
602: zst->zst_tbp = zst->zst_tbeg;
603: }
604: splx(s);
605: zsstart_tx(zst);
606: return (0);
607: }
608:
609: void
610: zsstart_tx(zst)
611: struct zskbd_softc *zst;
612: {
613: struct zs_chanstate *cs = zst->zst_cs;
614: int s, s1;
615:
616: s = spltty();
617:
618: if (zst->zst_tx_stopped)
619: goto out;
620: if (zst->zst_tbc == 0)
621: goto out;
622:
623: s1 = splzs();
624:
625: zst->zst_tx_busy = 1;
626:
627: if (!ISSET(cs->cs_preg[1], ZSWR1_TIE)) {
628: SET(cs->cs_preg[1], ZSWR1_TIE);
629: cs->cs_creg[1] = cs->cs_preg[1];
630: zs_write_reg(cs, 1, cs->cs_creg[1]);
631: }
632:
633: zs_write_data(cs, *zst->zst_tba);
634:
635: zst->zst_tbc--;
636: if (++zst->zst_tba == zst->zst_tend)
637: zst->zst_tba = zst->zst_tbeg;
638:
639: splx(s1);
640:
641: out:
642: splx(s);
643: }
644:
645: /*
646: * Compute interrupt enable bits and set in the pending bits. Called both
647: * in zsparam() and when PPS (pulse per second timing) state changes.
648: * Must be called at splzs().
649: */
650: static void
651: zs_maskintr(zst)
652: struct zskbd_softc *zst;
653: {
654: struct zs_chanstate *cs = zst->zst_cs;
655: int tmp15;
656:
657: cs->cs_rr0_mask = cs->cs_rr0_cts | cs->cs_rr0_dcd;
658: if (zst->zst_ppsmask != 0)
659: cs->cs_rr0_mask |= cs->cs_rr0_pps;
660: tmp15 = cs->cs_preg[15];
661: if (ISSET(cs->cs_rr0_mask, ZSRR0_DCD))
662: SET(tmp15, ZSWR15_DCD_IE);
663: else
664: CLR(tmp15, ZSWR15_DCD_IE);
665: if (ISSET(cs->cs_rr0_mask, ZSRR0_CTS))
666: SET(tmp15, ZSWR15_CTS_IE);
667: else
668: CLR(tmp15, ZSWR15_CTS_IE);
669: cs->cs_preg[15] = tmp15;
670: }
671:
672:
673: /*
674: * Raise or lower modem control (DTR/RTS) signals. If a character is
675: * in transmission, the change is deferred.
676: */
677: static void
678: zs_modem(zst, onoff)
679: struct zskbd_softc *zst;
680: int onoff;
681: {
682: struct zs_chanstate *cs = zst->zst_cs;
683:
684: if (cs->cs_wr5_dtr == 0)
685: return;
686:
687: if (onoff)
688: SET(cs->cs_preg[5], cs->cs_wr5_dtr);
689: else
690: CLR(cs->cs_preg[5], cs->cs_wr5_dtr);
691:
692: if (!cs->cs_heldchange) {
693: if (zst->zst_tx_busy) {
694: zst->zst_heldtbc = zst->zst_tbc;
695: zst->zst_tbc = 0;
696: cs->cs_heldchange = 1;
697: } else
698: zs_loadchannelregs(cs);
699: }
700: }
701:
702: /*
703: * Internal version of zshwiflow
704: * called at splzs
705: */
706: static void
707: zs_hwiflow(zst)
708: struct zskbd_softc *zst;
709: {
710: struct zs_chanstate *cs = zst->zst_cs;
711:
712: if (cs->cs_wr5_rts == 0)
713: return;
714:
715: if (ISSET(zst->zst_rx_flags, RX_ANY_BLOCK)) {
716: CLR(cs->cs_preg[5], cs->cs_wr5_rts);
717: CLR(cs->cs_creg[5], cs->cs_wr5_rts);
718: } else {
719: SET(cs->cs_preg[5], cs->cs_wr5_rts);
720: SET(cs->cs_creg[5], cs->cs_wr5_rts);
721: }
722: zs_write_reg(cs, 5, cs->cs_creg[5]);
723: }
724:
725:
726: /****************************************************************
727: * Interface to the lower layer (zscc)
728: ****************************************************************/
729:
730: #define integrate
731: integrate void zskbd_rxsoft(struct zskbd_softc *);
732: integrate void zskbd_txsoft(struct zskbd_softc *);
733: integrate void zskbd_stsoft(struct zskbd_softc *);
734: /*
735: * receiver ready interrupt.
736: * called at splzs
737: */
738: static void
739: zskbd_rxint(cs)
740: struct zs_chanstate *cs;
741: {
742: struct zskbd_softc *zst = cs->cs_private;
743: u_char *put, *end;
744: u_int cc;
745: u_char rr0, rr1, c;
746:
747: end = zst->zst_ebuf;
748: put = zst->zst_rbput;
749: cc = zst->zst_rbavail;
750:
751: while (cc > 0) {
752: /*
753: * First read the status, because reading the received char
754: * destroys the status of this char.
755: */
756: rr1 = zs_read_reg(cs, 1);
757: c = zs_read_data(cs);
758:
759: if (ISSET(rr1, ZSRR1_FE | ZSRR1_DO | ZSRR1_PE)) {
760: /* Clear the receive error. */
761: zs_write_csr(cs, ZSWR0_RESET_ERRORS);
762: }
763:
764: put[0] = c;
765: put[1] = rr1;
766: put += 2;
767: if (put >= end)
768: put = zst->zst_rbuf;
769: cc--;
770:
771: rr0 = zs_read_csr(cs);
772: if (!ISSET(rr0, ZSRR0_RX_READY))
773: break;
774: }
775:
776: /*
777: * Current string of incoming characters ended because
778: * no more data was available or we ran out of space.
779: * Schedule a receive event if any data was received.
780: * If we're out of space, turn off receive interrupts.
781: */
782: zst->zst_rbput = put;
783: zst->zst_rbavail = cc;
784: if (!ISSET(zst->zst_rx_flags, RX_TTY_OVERFLOWED)) {
785: zst->zst_rx_ready = 1;
786: cs->cs_softreq = 1;
787: }
788:
789: /*
790: * See if we are in danger of overflowing a buffer. If
791: * so, use hardware flow control to ease the pressure.
792: */
793: if (!ISSET(zst->zst_rx_flags, RX_IBUF_BLOCKED) &&
794: cc < zst->zst_r_hiwat) {
795: SET(zst->zst_rx_flags, RX_IBUF_BLOCKED);
796: zs_hwiflow(zst);
797: }
798:
799: /*
800: * If we're out of space, disable receive interrupts
801: * until the queue has drained a bit.
802: */
803: if (!cc) {
804: SET(zst->zst_rx_flags, RX_IBUF_OVERFLOWED);
805: CLR(cs->cs_preg[1], ZSWR1_RIE);
806: cs->cs_creg[1] = cs->cs_preg[1];
807: zs_write_reg(cs, 1, cs->cs_creg[1]);
808: }
809: }
810:
811: /*
812: * transmitter ready interrupt. (splzs)
813: */
814: static void
815: zskbd_txint(cs)
816: struct zs_chanstate *cs;
817: {
818: struct zskbd_softc *zst = cs->cs_private;
819:
820: /*
821: * If we've delayed a parameter change, do it now, and restart
822: * output.
823: */
824: if (cs->cs_heldchange) {
825: zs_loadchannelregs(cs);
826: cs->cs_heldchange = 0;
827: zst->zst_tbc = zst->zst_heldtbc;
828: zst->zst_heldtbc = 0;
829: }
830:
831: /* Output the next character in the buffer, if any. */
832: if (zst->zst_tbc > 0) {
833: zs_write_data(cs, *zst->zst_tba);
834: zst->zst_tbc--;
835: if (++zst->zst_tba == zst->zst_tend)
836: zst->zst_tba = zst->zst_tbeg;
837: } else {
838: /* Disable transmit completion interrupts if necessary. */
839: if (ISSET(cs->cs_preg[1], ZSWR1_TIE)) {
840: CLR(cs->cs_preg[1], ZSWR1_TIE);
841: cs->cs_creg[1] = cs->cs_preg[1];
842: zs_write_reg(cs, 1, cs->cs_creg[1]);
843: }
844: if (zst->zst_tx_busy) {
845: zst->zst_tx_busy = 0;
846: zst->zst_tx_done = 1;
847: cs->cs_softreq = 1;
848: }
849: }
850: }
851:
852: /*
853: * status change interrupt. (splzs)
854: */
855: static void
856: zskbd_stint(cs, force)
857: struct zs_chanstate *cs;
858: int force;
859: {
860: struct zskbd_softc *zst = cs->cs_private;
861: u_char rr0, delta;
862:
863: rr0 = zs_read_csr(cs);
864: zs_write_csr(cs, ZSWR0_RESET_STATUS);
865:
866: /*
867: * Check here for console break, so that we can abort
868: * even when interrupts are locking up the machine.
869: */
870: if (!force)
871: delta = rr0 ^ cs->cs_rr0;
872: else
873: delta = cs->cs_rr0_mask;
874: cs->cs_rr0 = rr0;
875:
876: if (ISSET(delta, cs->cs_rr0_mask)) {
877: SET(cs->cs_rr0_delta, delta);
878:
879: /*
880: * Stop output immediately if we lose the output
881: * flow control signal or carrier detect.
882: */
883: if (ISSET(~rr0, cs->cs_rr0_mask)) {
884: zst->zst_tbc = 0;
885: zst->zst_heldtbc = 0;
886: }
887:
888: zst->zst_st_check = 1;
889: cs->cs_softreq = 1;
890: }
891: }
892:
893: void
894: zskbd_diag(arg)
895: void *arg;
896: {
897: struct zskbd_softc *zst = arg;
898: struct sunkbd_softc *ss = arg;
899: int overflows, floods;
900: int s;
901:
902: s = splzs();
903: overflows = zst->zst_overflows;
904: zst->zst_overflows = 0;
905: floods = zst->zst_floods;
906: zst->zst_floods = 0;
907: zst->zst_errors = 0;
908: splx(s);
909:
910: log(LOG_WARNING, "%s: %d silo overflow%s, %d ibuf flood%s\n",
911: ss->sc_dev.dv_xname,
912: overflows, overflows == 1 ? "" : "s",
913: floods, floods == 1 ? "" : "s");
914: }
915:
916: integrate void
917: zskbd_rxsoft(zst)
918: struct zskbd_softc *zst;
919: {
920: struct sunkbd_softc *ss = (void *)zst;
921: struct zs_chanstate *cs = zst->zst_cs;
922: u_char *get, *end;
923: u_int cc, scc, type;
924: u_char rr1;
925: int code, value;
926: int s;
927:
928: end = zst->zst_ebuf;
929: get = zst->zst_rbget;
930: scc = cc = zskbd_rbuf_size - zst->zst_rbavail;
931:
932: if (cc == zskbd_rbuf_size) {
933: zst->zst_floods++;
934: if (zst->zst_errors++ == 0)
935: timeout_add(&zst->zst_diag_ch, 60 * hz);
936: }
937:
938: while (cc) {
939: code = get[0];
940: rr1 = get[1];
941: if (ISSET(rr1, ZSRR1_DO | ZSRR1_FE | ZSRR1_PE)) {
942: if (ISSET(rr1, ZSRR1_DO)) {
943: zst->zst_overflows++;
944: if (zst->zst_errors++ == 0)
945: timeout_add(&zst->zst_diag_ch, 60 * hz);
946: }
947: if (ISSET(rr1, ZSRR1_FE))
948: SET(code, TTY_FE);
949: if (ISSET(rr1, ZSRR1_PE))
950: SET(code, TTY_PE);
951: }
952:
953: sunkbd_decode(code, &type, &value);
954: wskbd_input(ss->sc_wskbddev, type, value);
955:
956: get += 2;
957: if (get >= end)
958: get = zst->zst_rbuf;
959: cc--;
960: }
961:
962: if (cc != scc) {
963: zst->zst_rbget = get;
964: s = splzs();
965: cc = zst->zst_rbavail += scc - cc;
966: /* Buffers should be ok again, release possible block. */
967: if (cc >= zst->zst_r_lowat) {
968: if (ISSET(zst->zst_rx_flags, RX_IBUF_OVERFLOWED)) {
969: CLR(zst->zst_rx_flags, RX_IBUF_OVERFLOWED);
970: SET(cs->cs_preg[1], ZSWR1_RIE);
971: cs->cs_creg[1] = cs->cs_preg[1];
972: zs_write_reg(cs, 1, cs->cs_creg[1]);
973: }
974: if (ISSET(zst->zst_rx_flags, RX_IBUF_BLOCKED)) {
975: CLR(zst->zst_rx_flags, RX_IBUF_BLOCKED);
976: zs_hwiflow(zst);
977: }
978: }
979: splx(s);
980: }
981: }
982:
983: integrate void
984: zskbd_txsoft(zst)
985: struct zskbd_softc *zst;
986: {
987: }
988:
989: integrate void
990: zskbd_stsoft(zst)
991: struct zskbd_softc *zst;
992: {
993: struct zs_chanstate *cs = zst->zst_cs;
994: u_char rr0, delta;
995: int s;
996:
997: s = splzs();
998: rr0 = cs->cs_rr0;
999: delta = cs->cs_rr0_delta;
1000: cs->cs_rr0_delta = 0;
1001: splx(s);
1002:
1003: if (ISSET(delta, cs->cs_rr0_cts)) {
1004: /* Block or unblock output according to flow control. */
1005: if (ISSET(rr0, cs->cs_rr0_cts))
1006: zst->zst_tx_stopped = 0;
1007: else
1008: zst->zst_tx_stopped = 1;
1009: }
1010: }
1011:
1012: /*
1013: * Software interrupt. Called at zssoft
1014: *
1015: * The main job to be done here is to empty the input ring
1016: * by passing its contents up to the tty layer. The ring is
1017: * always emptied during this operation, therefore the ring
1018: * must not be larger than the space after "high water" in
1019: * the tty layer, or the tty layer might drop our input.
1020: *
1021: * Note: an "input blockage" condition is assumed to exist if
1022: * EITHER the TS_TBLOCK flag or zst_rx_blocked flag is set.
1023: */
1024: static void
1025: zskbd_softint(cs)
1026: struct zs_chanstate *cs;
1027: {
1028: struct zskbd_softc *zst = cs->cs_private;
1029: int s;
1030:
1031: s = spltty();
1032:
1033: if (zst->zst_rx_ready) {
1034: zst->zst_rx_ready = 0;
1035: zskbd_rxsoft(zst);
1036: }
1037:
1038: if (zst->zst_st_check) {
1039: zst->zst_st_check = 0;
1040: zskbd_stsoft(zst);
1041: }
1042:
1043: if (zst->zst_tx_done) {
1044: zst->zst_tx_done = 0;
1045: zskbd_txsoft(zst);
1046: }
1047:
1048: splx(s);
1049: }
1050:
1051: struct zsops zsops_kbd = {
1052: zskbd_rxint, /* receive char available */
1053: zskbd_stint, /* external/status */
1054: zskbd_txint, /* xmit buffer empty */
1055: zskbd_softint, /* process software interrupt */
1056: };
1057:
1058: void
1059: zskbd_cnpollc(v, on)
1060: void *v;
1061: int on;
1062: {
1063: extern int swallow_zsintrs;
1064:
1065: if (on)
1066: swallow_zsintrs++;
1067: else
1068: swallow_zsintrs--;
1069: }
1070:
1071: void
1072: zskbd_cngetc(v, type, data)
1073: void *v;
1074: u_int *type;
1075: int *data;
1076: {
1077: struct zskbd_softc *zst = v;
1078: int s;
1079: u_int8_t c, rr0;
1080:
1081: s = splhigh();
1082: do {
1083: rr0 = *zst->zst_cs->cs_reg_csr;
1084: } while ((rr0 & ZSRR0_RX_READY) == 0);
1085:
1086: c = *zst->zst_cs->cs_reg_data;
1087: splx(s);
1088:
1089: switch (c) {
1090: case SKBD_RSP_IDLE:
1091: *type = WSCONS_EVENT_ALL_KEYS_UP;
1092: *data = 0;
1093: break;
1094: default:
1095: *type = (c & 0x80) ?
1096: WSCONS_EVENT_KEY_UP : WSCONS_EVENT_KEY_DOWN;
1097: *data = c & 0x7f;
1098: break;
1099: }
1100: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to z8530kbd.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / sparc64 / dev