bsd/dev/arm/km.c

   1 /*
   2  * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
   3  */
   4 /*
   5  * Copyright (c) 1992 NeXT Computer, Inc.  All rights reserved.
   6  *
   7  * km.m - kernel keyboard/monitor module, procedural interface.
   8  *
   9  * HISTORY
  10  */
  11 #include <sys/param.h>
  12 #include <sys/tty.h>
  13
  14 #include <machine/cons.h>
  15 #include <sys/conf.h>
  16 #include <sys/systm.h>
  17 #include <sys/uio.h>
  18 #include <sys/fcntl.h>          /* for kmopen */
  19 #include <sys/errno.h>
  20 #include <sys/proc.h>           /* for kmopen */
  21 #include <sys/msgbuf.h>
  22 #include <sys/time.h>
  23 #include <dev/kmreg_com.h>
  24 #include <pexpert/pexpert.h>
  25 #include <console/serial_protos.h>
  26
  27 extern int      hz;
  28
  29 extern void     cnputcusr(char);
  30 extern void     cnputsusr(char *, int);
  31 extern int      cngetc(void);
  32
  33
  34 void    kminit(void);
  35 void    cons_cinput(char ch);
  36
  37 /*
  38  * 'Global' variables, shared only by this file and conf.c.
  39  */
  40 struct tty     *km_tty[1] = { 0 };
  41
  42 /*
  43  * this works early on, after initialize_screen() but before autoconf (and thus
  44  * before we have a kmDevice).
  45  */
  46 int             disableConsoleOutput;
  47
  48 /*
  49  * 'Global' variables, shared only by this file and kmDevice.m.
  50  */
  51 int             initialized = 0;
  52
  53 static int      kmoutput(struct tty * tp);
  54 static void     kmstart(struct tty * tp);
  55
  56 extern void     KeyboardOpen(void);
  57
  58 void
  59 kminit(void)
  60 {
  61         km_tty[0] = ttymalloc();
  62         km_tty[0]->t_dev = makedev(12, 0);
  63         initialized = 1;
  64 }
  65
  66 /*
  67  * cdevsw interface to km driver.
  68  */
  69 int
  70 kmopen(dev_t dev, int flag, __unused int devtype, proc_t pp)
  71 {
  72         int             unit;
  73         struct tty     *tp;
  74         struct winsize *wp;
  75         int             ret;
  76
  77         unit = minor(dev);
  78         if (unit >= 1)
  79                 return (ENXIO);
  80
  81         tp = km_tty[unit];
  82
  83         tty_lock(tp);
  84
  85         tp->t_oproc = kmstart;
  86         tp->t_param = NULL;
  87         tp->t_dev = dev;
  88
  89         if (!(tp->t_state & TS_ISOPEN)) {
  90                 tp->t_iflag = TTYDEF_IFLAG;
  91                 tp->t_oflag = TTYDEF_OFLAG;
  92                 tp->t_cflag = (CREAD | CS8 | CLOCAL);
  93                 tp->t_lflag = TTYDEF_LFLAG;
  94                 tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
  95                 termioschars(&tp->t_termios);
  96                 ttsetwater(tp);
  97         } else if ((tp->t_state & TS_XCLUDE) && proc_suser(pp)) {
  98                 ret = EBUSY;
  99                 goto out;
 100         }
 101
 102         tp->t_state |= TS_CARR_ON;      /* lie and say carrier exists and is
 103                                          * on. */
 104         ret = ((*linesw[tp->t_line].l_open) (dev, tp));
 105         {
 106                 PE_Video        video;
 107                 wp = &tp->t_winsize;
 108                 /*
 109                  * Magic numbers.  These are CHARWIDTH and CHARHEIGHT from
 110                  * pexpert/i386/video_console.c
 111                  */
 112                 wp->ws_xpixel = 8;
 113                 wp->ws_ypixel = 16;
 114
 115                 tty_unlock(tp);         /* XXX race window */
 116
 117                 if (flag & O_POPUP)
 118                         PE_initialize_console(0, kPETextScreen);
 119
 120                 bzero(&video, sizeof(video));
 121                 PE_current_console(&video);
 122
 123                 tty_lock(tp);
 124
 125                 if (serialmode & SERIALMODE_OUTPUT) {
 126                         wp->ws_col = 80;
 127                         wp->ws_row = 24;
 128                 } else if (video.v_width != 0 && video.v_height != 0) {
 129                         wp->ws_col = video.v_width / wp->ws_xpixel;
 130                         wp->ws_row = video.v_height / wp->ws_ypixel;
 131                 } else {
 132                         wp->ws_col = 100;
 133                         wp->ws_row = 36;
 134                 }
 135         }
 136
 137 out:
 138         tty_unlock(tp);
 139
 140         return ret;
 141 }
 142
 143 int
 144 kmclose(dev_t dev, int flag, __unused int mode, __unused proc_t p)
 145 {
 146         int ret;
 147         struct tty *tp = km_tty[minor(dev)];
 148
 149         tty_lock(tp);
 150         ret = (*linesw[tp->t_line].l_close)(tp, flag);
 151         ttyclose(tp);
 152         tty_unlock(tp);
 153
 154         return (ret);
 155 }
 156
 157 int
 158 kmread(dev_t dev, struct uio * uio, int ioflag)
 159 {
 160         int ret;
 161         struct tty *tp = km_tty[minor(dev)];
 162
 163         tty_lock(tp);
 164         ret = (*linesw[tp->t_line].l_read)(tp, uio, ioflag);
 165         tty_unlock(tp);
 166
 167         return (ret);
 168 }
 169
 170 int
 171 kmwrite(dev_t dev, struct uio * uio, int ioflag)
 172 {
 173         int ret;
 174         struct tty *tp = km_tty[minor(dev)];
 175
 176         tty_lock(tp);
 177         ret = (*linesw[tp->t_line].l_write)(tp, uio, ioflag);
 178         tty_unlock(tp);
 179
 180         return (ret);
 181 }
 182
 183 int
 184 kmioctl(dev_t dev, u_long cmd, caddr_t data, int flag, proc_t p)
 185 {
 186         int             error = 0;
 187         struct tty *tp = km_tty[minor(dev)];
 188         struct winsize *wp;
 189
 190         tty_lock(tp);
 191
 192         switch (cmd) {
 193         case KMIOCSIZE:
 194                 wp = (struct winsize *) data;
 195                 *wp = tp->t_winsize;
 196                 break;
 197
 198         case TIOCSWINSZ:
 199                 /*
 200                  * Prevent changing of console size -- this ensures that
 201                  * login doesn't revert to the termcap-defined size
 202                  */
 203                 error = EINVAL;
 204                 break;
 205
 206                 /* Bodge in the CLOCAL flag as the km device is always local */
 207         case TIOCSETA_32:
 208         case TIOCSETAW_32:
 209         case TIOCSETAF_32:
 210                 {
 211                         struct termios32 *t = (struct termios32 *)data;
 212                         t->c_cflag |= CLOCAL;
 213                         /* No Break */
 214                 }
 215                 goto fallthrough;
 216         case TIOCSETA_64:
 217         case TIOCSETAW_64:
 218         case TIOCSETAF_64:
 219                 {
 220                         struct user_termios *t = (struct user_termios *)data;
 221                         t->c_cflag |= CLOCAL;
 222                         /* No Break */
 223                 }
 224 fallthrough:
 225         default:
 226                 error = (*linesw[tp->t_line].l_ioctl) (tp, cmd, data, flag, p);
 227                 if (ENOTTY != error)
 228                         break;
 229                 error = ttioctl_locked(tp, cmd, data, flag, p);
 230                 break;
 231         }
 232
 233         tty_unlock(tp);
 234
 235         return (error);
 236 }
 237
 238
 239 /*
 240  * kmputc
 241  *
 242  * Output a character to the serial console driver via cnputcusr(),
 243  * which is exported by that driver.
 244  *
 245  * Locks:       Assumes tp in the calling tty driver code is locked on
 246  *              entry, remains locked on exit
 247  *
 248  * Notes:       Called from kmoutput(); giving the locking output
 249  *              assumptions here, this routine should be static (and
 250  *              inlined, given there is only one call site).
 251  */
 252 int
 253 kmputc(__unused dev_t dev, char c)
 254 {
 255         if(!disableConsoleOutput && initialized) {
 256                 /* OCRNL */
 257                 if(c == '\n')
 258                         cnputcusr('\r');
 259                 cnputcusr(c);
 260         }
 261
 262         return (0);
 263 }
 264
 265
 266 /*
 267  * Callouts from linesw.
 268  */
 269
 270 #define KM_LOWAT_DELAY  ((ns_time_t)1000)
 271
 272 /*
 273  * t_oproc for this driver; called from within the line discipline
 274  *
 275  * Locks:       Assumes tp is locked on entry, remains locked on exit
 276  */
 277 static void
 278 kmstart(struct tty *tp)
 279 {
 280         if (tp->t_state & (TS_TIMEOUT | TS_BUSY | TS_TTSTOP))
 281                 goto out;
 282         if (tp->t_outq.c_cc == 0)
 283                 goto out;
 284         tp->t_state |= TS_BUSY;
 285         if (tp->t_outq.c_cc > tp->t_lowat) {
 286                 /*
 287                  * Start immediately.
 288                  */
 289                 kmoutput(tp);
 290         } else {
 291                 /*
 292                  * Wait a bit...
 293                  */
 294 #if 0
 295                 /* FIXME */
 296                 timeout(kmtimeout, tp, hz);
 297 #else
 298                 kmoutput(tp);
 299 #endif
 300         }
 301         return;
 302
 303 out:
 304         (*linesw[tp->t_line].l_start) (tp);
 305         return;
 306 }
 307
 308 /*
 309  * One-shot output retry timeout from kmoutput(); re-calls kmoutput() at
 310  * intervals until the output queue for the tty is empty, at which point
 311  * the timeout is not rescheduled by kmoutput()
 312  *
 313  * This function must take the tty_lock() around the kmoutput() call; it
 314  * ignores the return value.
 315  */
 316 static void
 317 kmtimeout(void *arg)
 318 {
 319         struct tty     *tp = (struct tty *)arg;
 320
 321         tty_lock(tp);
 322         (void)kmoutput(tp);
 323         tty_unlock(tp);
 324 }
 325
 326 /*
 327  * kmoutput
 328  *
 329  * Locks:       Assumes tp is locked on entry, remains locked on exit
 330  *
 331  * Notes:       Called from kmstart() and kmtimeout(); kmtimeout() is a
 332  *              timer initiated by this routine to deal with pending
 333  *              output not yet flushed (output is flushed at a maximum
 334  *              of sizeof(buf) charatcers at a time before dropping into
 335  *              the timeout code).
 336  */
 337 static int
 338 kmoutput(struct tty * tp)
 339 {
 340         unsigned char   buf[80];        /* buffer; limits output per call */
 341         unsigned char   *cp;
 342         int     cc = -1;
 343
 344         /* While there is data available to be output... */
 345         while (tp->t_outq.c_cc > 0) {
 346                 cc = ndqb(&tp->t_outq, 0);
 347                 if (cc == 0)
 348                         break;
 349                 /*
 350                  * attempt to output as many characters as are available,
 351                  * up to the available transfer buffer size.
 352                  */
 353                 cc = min(cc, sizeof(buf));
 354                 /* copy the output queue contents to the buffer */
 355                 (void) q_to_b(&tp->t_outq, buf, cc);
 356                 for (cp = buf; cp < &buf[cc]; cp++) {
 357                         /* output the buffer one charatcer at a time */
 358                         *cp = *cp & 0x7f;
 359                 }
 360                 if (cc > 1) {
 361                         cnputsusr((char *)buf, cc);
 362                 } else {
 363                         kmputc(tp->t_dev, *buf);
 364                 }
 365         }
 366         /*
 367          * XXX This is likely not necessary, as the tty output queue is not
 368          * XXX writeable while we hold the tty_lock().
 369          */
 370         if (tp->t_outq.c_cc > 0) {
 371                 timeout(kmtimeout, tp, hz);
 372         }
 373         tp->t_state &= ~TS_BUSY;
 374         /* Start the output processing for the line discipline */
 375         (*linesw[tp->t_line].l_start) (tp);
 376
 377         return 0;
 378 }
 379
 380
 381 /*
 382  * cons_cinput
 383  *
 384  * Driver character input from the polled mode serial console driver calls
 385  * this routine to input a character from the serial driver into the tty
 386  * line discipline specific input processing receiv interrupt routine,
 387  * l_rint().
 388  *
 389  * Locks:       Assumes that the tty_lock() is NOT held on the tp, so a
 390  *              serial driver should NOT call this function as a result
 391  *              of being called from a function which already holds the
 392  *              lock; ECHOE will be handled at the line discipline, if
 393  *              output echo processing is going to occur.
 394  */
 395 void
 396 cons_cinput(char ch)
 397 {
 398         struct tty *tp = km_tty[0];     /* XXX */
 399
 400         tty_lock(tp);
 401         (*linesw[tp->t_line].l_rint) (ch, tp);
 402         tty_unlock(tp);
 403 }