1 /* $NetBSD: sunkbd.c,v 1.30 2017/10/31 10:46:47 martin Exp $ */ 2 3 /* 4 * Copyright (c) 1992, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * This software was developed by the Computer Systems Engineering group 8 * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and 9 * contributed to Berkeley. 10 * 11 * All advertising materials mentioning features or use of this software 12 * must display the following acknowledgement: 13 * This product includes software developed by the University of 14 * California, Lawrence Berkeley Laboratory. 15 * 16 * Redistribution and use in source and binary forms, with or without 17 * modification, are permitted provided that the following conditions 18 * are met: 19 * 1. Redistributions of source code must retain the above copyright 20 * notice, this list of conditions and the following disclaimer. 21 * 2. Redistributions in binary form must reproduce the above copyright 22 * notice, this list of conditions and the following disclaimer in the 23 * documentation and/or other materials provided with the distribution. 24 * 3. Neither the name of the University nor the names of its contributors 25 * may be used to endorse or promote products derived from this software 26 * without specific prior written permission. 27 * 28 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 29 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 30 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 31 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 32 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 33 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 34 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 35 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 36 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 37 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 38 * SUCH DAMAGE. 39 * 40 * @(#)kbd.c 8.2 (Berkeley) 10/30/93 41 */ 42 43 /* 44 * /dev/kbd lower layer for sun keyboard off a tty (line discipline). 45 * This driver uses kbdsun middle layer to hook up to /dev/kbd. 46 */ 47 48 /* 49 * Keyboard interface line discipline. 50 * 51 */ 52 53 #include <sys/cdefs.h> 54 __KERNEL_RCSID(0, "$NetBSD: sunkbd.c,v 1.30 2017/10/31 10:46:47 martin Exp $"); 55 56 #include <sys/param.h> 57 #include <sys/systm.h> 58 #include <sys/conf.h> 59 #include <sys/device.h> 60 #include <sys/kernel.h> 61 #include <sys/malloc.h> 62 #include <sys/proc.h> 63 #include <sys/signal.h> 64 #include <sys/signalvar.h> 65 #include <sys/time.h> 66 #include <sys/select.h> 67 #include <sys/syslog.h> 68 #include <sys/fcntl.h> 69 #include <sys/tty.h> 70 71 #include <dev/cons.h> 72 #include <machine/vuid_event.h> 73 #include <machine/kbd.h> 74 #include <dev/sun/event_var.h> 75 #include <dev/sun/kbd_xlate.h> 76 #include <dev/sun/kbdvar.h> 77 #include <dev/sun/kbdsunvar.h> 78 #include <dev/sun/kbd_ms_ttyvar.h> 79 80 /**************************************************************** 81 * Interface to the lower layer (ttycc) 82 ****************************************************************/ 83 84 static int sunkbd_match(device_t, cfdata_t, void *); 85 static void sunkbd_attach(device_t, device_t, void *); 86 static void sunkbd_write_data(struct kbd_sun_softc *, int); 87 static int sunkbdiopen(device_t, int mode); 88 89 #if NWSKBD > 0 90 void kbd_wskbd_attach(struct kbd_softc *k, int isconsole); 91 #endif 92 93 int sunkbdinput(int, struct tty *); 94 int sunkbdstart(struct tty *); 95 96 /* Default keyboard baud rate */ 97 int sunkbd_bps = KBD_DEFAULT_BPS; 98 99 CFATTACH_DECL_NEW(kbd_tty, sizeof(struct kbd_sun_softc), 100 sunkbd_match, sunkbd_attach, NULL, NULL); 101 102 struct linesw sunkbd_disc = { 103 .l_name = "sunkbd", 104 .l_open = ttylopen, 105 .l_close = ttylclose, 106 .l_read = ttyerrio, 107 .l_write = ttyerrio, 108 .l_ioctl = ttynullioctl, 109 .l_rint = sunkbdinput, 110 .l_start = sunkbdstart, 111 .l_modem = nullmodem, 112 .l_poll = ttpoll 113 }; 114 115 116 /* 117 * sunkbd_match: how is this tty channel configured? 118 */ 119 int 120 sunkbd_match(device_t parent, cfdata_t cf, void *aux) 121 { 122 struct kbd_ms_tty_attach_args *args = aux; 123 124 if (strcmp(args->kmta_name, "keyboard") == 0) 125 return 1; 126 127 return 0; 128 } 129 130 void 131 sunkbd_attach(device_t parent, device_t self, void *aux) 132 { 133 struct kbd_sun_softc *k = device_private(self); 134 struct kbd_ms_tty_attach_args *args = aux; 135 struct tty *tp = args->kmta_tp; 136 struct cons_channel *cc; 137 138 k->k_kbd.k_dev = self; 139 140 /* Set up the proper line discipline. */ 141 if (ttyldisc_attach(&sunkbd_disc) != 0) 142 panic("sunkbd_attach: sunkbd_disc"); 143 ttyldisc_release(tp->t_linesw); 144 tp->t_linesw = ttyldisc_lookup(sunkbd_disc.l_name); 145 KASSERT(tp->t_linesw == &sunkbd_disc); 146 tp->t_oflag &= ~OPOST; 147 tp->t_dev = args->kmta_dev; 148 SET(tp->t_state, TS_KERN_ONLY); 149 150 /* link the structures together. */ 151 k->k_priv = tp; 152 tp->t_sc = k; 153 154 /* provide our middle layer with a link to the lower layer (i.e. us) */ 155 k->k_deviopen = sunkbdiopen; 156 k->k_deviclose = NULL; 157 k->k_write_data = sunkbd_write_data; 158 159 /* provide upper layer with a link to our middle layer */ 160 k->k_kbd.k_ops = &kbd_ops_sun; 161 162 /* alloc console input channel */ 163 if ((cc = kbd_cc_alloc(&k->k_kbd)) == NULL) 164 return; 165 166 if (args->kmta_consdev) { 167 char magic[4]; 168 169 /* 170 * Hookup ourselves as the console input channel 171 */ 172 args->kmta_baud = sunkbd_bps; 173 args->kmta_cflag = CLOCAL|CS8; 174 cons_attach_input(cc, args->kmta_consdev); 175 176 /* Tell our parent what the console should be. */ 177 args->kmta_consdev = cn_tab; 178 k->k_kbd.k_isconsole = 1; 179 aprint_normal(" (console input)"); 180 181 /* Set magic to "L1-A" */ 182 magic[0] = KBD_L1; 183 magic[1] = KBD_A; 184 magic[2] = 0; 185 cn_set_magic(magic); 186 } else { 187 extern void kd_attach_input(struct cons_channel *); 188 189 kd_attach_input(cc); 190 } 191 192 193 aprint_normal("\n"); 194 195 #if NWSKBD > 0 196 kbd_wskbd_attach(&k->k_kbd, args->kmta_consdev != NULL); 197 #endif 198 199 /* Do this before any calls to kbd_rint(). */ 200 kbd_xlate_init(&k->k_kbd.k_state); 201 202 /* Magic sequence. */ 203 k->k_magic1 = KBD_L1; 204 k->k_magic2 = KBD_A; 205 } 206 207 /* 208 * Internal open routine. This really should be inside com.c 209 * But I'm putting it here until we have a generic internal open 210 * mechanism. 211 */ 212 int 213 sunkbdiopen(device_t dev, int flags) 214 { 215 struct kbd_sun_softc *k = device_private(dev); 216 struct tty *tp = k->k_priv; 217 struct lwp *l = curlwp ? curlwp : &lwp0; 218 struct termios t; 219 int error; 220 221 /* Open the lower device */ 222 CLR(tp->t_state, TS_KERN_ONLY); 223 if ((error = cdev_open(tp->t_dev, O_NONBLOCK|flags, 224 0/* ignored? */, l)) != 0) 225 return (error); 226 227 /* Now configure it for the console. */ 228 tp->t_ospeed = 0; 229 t.c_ispeed = sunkbd_bps; 230 t.c_ospeed = sunkbd_bps; 231 t.c_cflag = CLOCAL|CS8; 232 (*tp->t_param)(tp, &t); 233 SET(tp->t_state, TS_KERN_ONLY); 234 235 return (0); 236 } 237 238 /* 239 * TTY interface to handle input. 240 */ 241 int 242 sunkbdinput(int c, struct tty *tp) 243 { 244 struct kbd_sun_softc *k = tp->t_sc; 245 int error; 246 247 /* 248 * Handle exceptional conditions (break, parity, framing). 249 */ 250 if ((error = ((c & TTY_ERRORMASK))) != 0) { 251 /* 252 * After garbage, flush pending input, and 253 * send a reset to resync key translation. 254 */ 255 log(LOG_ERR, "%s: input error (0x%x)\n", 256 device_xname(k->k_kbd.k_dev), c); 257 c &= TTY_CHARMASK; 258 if (!(k->k_txflags & K_TXBUSY)) { 259 ttyflush(tp, FREAD | FWRITE); 260 goto send_reset; 261 } 262 } 263 264 /* 265 * Check for input buffer overflow 266 */ 267 if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= TTYHOG) { 268 log(LOG_ERR, "%s: input overrun\n", 269 device_xname(k->k_kbd.k_dev)); 270 goto send_reset; 271 } 272 273 /* Pass this up to the "middle" layer. */ 274 return(kbd_sun_input(k, c)); 275 276 send_reset: 277 /* Send a reset to resync translation. */ 278 kbd_sun_output(k, KBD_CMD_RESET); 279 return (ttstart(tp)); 280 281 } 282 283 int 284 sunkbdstart(struct tty *tp) 285 { 286 struct kbd_sun_softc *k = tp->t_sc; 287 288 /* 289 * Transmit done. Try to send more, or 290 * clear busy and wakeup drain waiters. 291 */ 292 k->k_txflags &= ~K_TXBUSY; 293 kbd_sun_start_tx(k); 294 ttstart(tp); 295 return (0); 296 } 297 /* 298 * used by kbd_sun_start_tx(); 299 */ 300 void 301 sunkbd_write_data(struct kbd_sun_softc *k, int c) 302 { 303 struct tty *tp = k->k_priv; 304 305 mutex_spin_enter(&tty_lock); 306 ttyoutput(c, tp); 307 ttstart(tp); 308 mutex_spin_exit(&tty_lock); 309 } 310