bsd/dev/i386/cons.c

   1 /*
   2  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28 /*
  29  * Copyright (c) 1987, 1988 NeXT, Inc.
  30  *
  31  * HISTORY
  32  *  7-Jan-93  Mac Gillon (mgillon) at NeXT
  33  *      Integrated POSIX support
  34  *
  35  * 12-Aug-87  John Seamons (jks) at NeXT
  36  *      Ported to NeXT.
  37  */
  38
  39 /*
  40  * Indirect driver for console.
  41  */
  42 #include <sys/param.h>
  43 #include <sys/systm.h>
  44 #include <sys/conf.h>
  45 #include <sys/ioctl.h>
  46 #include <sys/tty.h>
  47 #include <sys/proc.h>
  48 #include <sys/uio.h>
  49
  50 struct tty      cons;
  51 struct tty      *constty;               /* current console device */
  52
  53 int cnopen(__unused dev_t dev, int flag, int devtype, struct proc *pp);
  54 int cnclose(__unused dev_t dev, int flag, int mode, struct proc *pp);
  55 int cnread(__unused dev_t dev, struct uio *uio, int ioflag);
  56 int cnwrite(__unused dev_t dev, struct uio *uio, int ioflag);
  57 int cnioctl(__unused dev_t dev, int cmd, caddr_t addr, int flg, struct proc *p);
  58 int cnselect(__unused dev_t dev, int flag, void * wql, struct proc *p);
  59
  60 void slave_cnenable(void);
  61
  62 int alert(
  63         __unused int width,
  64         __unused int height,
  65         __unused const char *title,
  66         const char *msg,
  67         int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8);
  68 int alert_done(void);
  69
  70 /*ARGSUSED*/
  71 int
  72 cnopen(__unused dev_t dev, int flag, int devtype, struct proc *pp)
  73 {
  74         dev_t device;
  75         boolean_t funnel_state;
  76         int error;
  77
  78         funnel_state = thread_funnel_set(kernel_flock, TRUE);
  79
  80         if (constty)
  81             device = constty->t_dev;
  82         else
  83             device = cons.t_dev;
  84         error =  (*cdevsw[major(device)].d_open)(device, flag, devtype, pp);
  85         thread_funnel_set(kernel_flock, funnel_state);
  86
  87         return(error);
  88 }
  89
  90 /*ARGSUSED*/
  91 int
  92 cnclose(__unused dev_t dev, int flag, int mode, struct proc *pp)
  93 {
  94         dev_t device;
  95         boolean_t funnel_state;
  96         int error;
  97
  98         funnel_state = thread_funnel_set(kernel_flock, TRUE);
  99         if (constty)
 100             device = constty->t_dev;
 101         else
 102             device = cons.t_dev;
 103         error =  (*cdevsw[major(device)].d_close)(device, flag, mode, pp);
 104         thread_funnel_set(kernel_flock, funnel_state);
 105
 106         return(error);
 107
 108
 109 }
 110
 111 /*ARGSUSED*/
 112 int
 113 cnread(__unused dev_t dev, struct uio *uio, int ioflag)
 114 {
 115         dev_t device;
 116         boolean_t funnel_state;
 117         int error;
 118
 119         funnel_state = thread_funnel_set(kernel_flock, TRUE);
 120         if (constty)
 121             device = constty->t_dev;
 122         else
 123             device = cons.t_dev;
 124         error = (*cdevsw[major(device)].d_read)(device, uio, ioflag);
 125         thread_funnel_set(kernel_flock, funnel_state);
 126
 127         return(error);
 128 }
 129
 130 /*ARGSUSED*/
 131 int
 132 cnwrite(__unused dev_t dev, struct uio *uio, int ioflag)
 133 {
 134     dev_t device;
 135         boolean_t funnel_state;
 136         int error;
 137
 138         funnel_state = thread_funnel_set(kernel_flock, TRUE);
 139         if (constty)
 140             device = constty->t_dev;
 141         else
 142             device = cons.t_dev;
 143     error =  (*cdevsw[major(device)].d_write)(device, uio, ioflag);
 144         thread_funnel_set(kernel_flock, funnel_state);
 145
 146         return(error);
 147 }
 148
 149 /*ARGSUSED*/
 150 int
 151 cnioctl(__unused dev_t dev, int cmd, caddr_t addr, int flag, struct proc *p)
 152 {
 153         dev_t device;
 154         boolean_t funnel_state;
 155         int error;
 156
 157         funnel_state = thread_funnel_set(kernel_flock, TRUE);
 158
 159         if (constty)
 160             device = constty->t_dev;
 161         else
 162             device = cons.t_dev;
 163         /*
 164          * Superuser can always use this to wrest control of console
 165          * output from the "virtual" console.
 166          */
 167         if ((unsigned) cmd == TIOCCONS && constty) {
 168                 error = proc_suser(p);
 169                 if (error) {
 170                         goto out;
 171                 }
 172                 constty = NULL;
 173                 error = 0;
 174                 goto out;
 175         }
 176         error =  (*cdevsw[major(device)].d_ioctl)(device, cmd, addr, flag, p);
 177 out:
 178         thread_funnel_set(kernel_flock, funnel_state);
 179
 180         return(error);
 181 }
 182
 183 /*ARGSUSED*/
 184 /* called with funnel held */
 185 int
 186 cnselect(__unused dev_t dev, int flag, void * wql, struct proc *p)
 187 {
 188         dev_t device;
 189
 190         if (constty)
 191             device = constty->t_dev;
 192         else
 193             device = cons.t_dev;
 194         return ((*cdevsw[major(device)].d_select)(device, flag, wql, p));
 195 }
 196
 197 #if 0   /* FIXME  - using OSFMK console driver for the moment */
 198 int
 199 cngetc()
 200 {
 201         dev_t device;
 202         boolean_t funnel_state;
 203         int error;
 204
 205         funnel_state = thread_funnel_set(kernel_flock, TRUE);
 206         if (constty)
 207             device = constty->t_dev;
 208         else
 209             device = cons.t_dev;
 210         error =  (*cdevsw[major(device)].d_getc)(device);
 211         thread_funnel_set(kernel_flock, funnel_state);
 212
 213         return(error);
 214 }
 215
 216 /*ARGSUSED*/
 217 int
 218 cnputc(c)
 219         char c;
 220 {
 221         dev_t device;
 222         boolean_t funnel_state;
 223         int error;
 224
 225         funnel_state = thread_funnel_set(kernel_flock, TRUE);
 226         if (constty)
 227             device = constty->t_dev;
 228         else
 229             device = cons.t_dev;
 230         error =  (*cdevsw[major(device)].d_putc)(device, c);
 231         thread_funnel_set(kernel_flock, funnel_state);
 232
 233         return(error);
 234 }
 235 #endif
 236
 237 void
 238 slave_cnenable(void)
 239 {
 240         /* FIXME: what to do here? */
 241 }
 242
 243 #if 0
 244 void
 245 kprintf( const char *format, ...)
 246 {
 247         /* on PPC this outputs to the serial line */
 248         /* nop on intel ... umeshv@apple.com */
 249
 250 }
 251 #endif
 252
 253 /*
 254  * Write message to console; create an alert panel if no text-type window
 255  * currently exists. Caller must call alert_done() when finished.
 256  * The height and width arguments are not used; they are provided for
 257  * compatibility with the 68k version of alert().
 258  */
 259 int
 260 alert(
 261         __unused int width,
 262         __unused int height,
 263         __unused const char *title,
 264         const char *msg,
 265         int p1,
 266         int p2,
 267         int p3,
 268         int p4,
 269         int p5,
 270         int p6,
 271         int p7,
 272         int p8)
 273 {
 274         char smsg[200];
 275
 276         sprintf(smsg, msg,  p1, p2, p3, p4, p5, p6, p7, p8);
 277 #if FIXME  /* [ */
 278         /* DoAlert(title, smsg); */
 279 #else
 280         printf("%s\n",smsg);
 281 #endif  /* FIXME ] */
 282
 283         return 0;
 284 }
 285
 286 int
 287 alert_done(void)
 288 {
 289         /* DoRestore(); */
 290         return 0;
 291 }
 292