6853 built in fonts are exposing internal data

[unleashed.git] / usr / src / uts / intel / io / polled_io.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
#pragma ident   "%Z%%M% %I%     %E% SMI"

#include <sys/stropts.h>
#include <sys/devops.h>
#include <sys/modctl.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/promif.h>
#include <sys/note.h>
#include <sys/consdev.h>
#include <sys/polled_io.h>

/*
 * consconfig is aware of which devices are the stdin and stout.  The
 * post-attach/pre-detach functions are an extension of consconfig because
 * they know about the dynamic changes to the stdin device.  Neither an
 * individual driver nor the DDI framework knows what device is really the
 * stdin.
 */
/*
 * Issues:
 *      o There are probably race conditions between vx_handler for "read"
 *        being called by OBP and the update of the polled_input_t
 *        structure.  We need to be careful how the structure is updated.
 *
 * Solaris/Intel note:  While OBP is not in the picture, there are probably
 * similar issues with kmdb.
 */

#if     defined(MAYBE_SOMETIME)
static void     polled_give_input(void);
static void     polled_take_input(void);
static void     polled_give_output(void);
static void     polled_take_output(void);

static void     polled_io_register(cons_polledio_t *,
                        polled_io_console_type_t, int);

static void     polled_io_unregister(polled_io_console_type_t, int);


/*
 * Make the registered device become the console for OBP
 */
static int      polled_io_take_console(polled_io_console_type_t, int);

/*
 * Restore the old console device for OBP.
 */
static int      polled_io_release_console(polled_io_console_type_t, int);
#endif  /* MAYBE_SOMETIME */

static polled_device_t  polled_input_device;
static polled_device_t  polled_output_device;

/*
 * This routine is called to initialize polled I/O.  We insert our entry
 * points so that OBP will call into this code when the switch is thrown
 * in polled_io_take_console().
 */
void
polled_io_init(void)
{
        /*
         * Initialize lock to protect multiple thread access to the
         * polled_input_device structure.  This does not protect
         * us from access in OBP mode.
         */
        mutex_init(&polled_input_device.polled_device_lock,
                NULL, MUTEX_DRIVER, NULL);

        /*
         * Initialize lock to protect multiple thread access to the
         * polled_output_device structure.  This does not protect
         * us from access in OBP mode.
         */
        mutex_init(&polled_output_device.polled_device_lock,
                NULL, MUTEX_DRIVER, NULL);
}

/*
 * Register a device for input or output.  The polled_io structure
 * will be filled in with the callbacks that are appropriate for
 * that device.
 */
int
polled_io_register_callbacks(
cons_polledio_t                 *polled_io,
int                             flags
)
{
#if     defined(MAYBE_SOMETIME)
        /*
         * If the input structure entries are filled in, then register this
         * structure as an input device.
         */
        if ((polled_io->cons_polledio_getchar != NULL) &&
                (polled_io->cons_polledio_ischar != NULL)) {

                polled_io_register(polled_io,
                        POLLED_IO_CONSOLE_INPUT, flags);
        }

        /*
         * If the output structure entries are filled in, then register this
         * structure as an output device.
         */
        if (polled_io->cons_polledio_putchar != NULL) {

                polled_io_register(polled_io,
                        POLLED_IO_CONSOLE_OUTPUT, flags);
        }
#else
_NOTE(ARGUNUSED(flags))
        cons_polledio = polled_io;
#endif

        return (DDI_SUCCESS);
}

/*
 * Unregister a device for console input/output.
 */
int
polled_io_unregister_callbacks(
cons_polledio_t                 *polled_io,
int                             flags
)
{
#if     defined(MAYBE_SOMETIME)
        /*
         * If polled_io is being used for input, then unregister it.
         */
        if (polled_io == polled_input_device.polled_io) {

                polled_io_unregister(
                        POLLED_IO_CONSOLE_INPUT, flags);
        }

        /*
         * If polled_io is being used for output, then unregister it.
         */
        if (polled_io == polled_output_device.polled_io) {

                polled_io_unregister(
                        POLLED_IO_CONSOLE_OUTPUT, flags);
        }
#else
_NOTE(ARGUNUSED(polled_io,flags))
#endif  /* MAYBE_SOMETIME */

        return (DDI_SUCCESS);
}

/*
 * This routine is called when we are done handling polled io.  We will
 * remove all of our handlers and destroy any memory that we have allocated.
 */
void
polled_io_fini()
{
        /*
         * Destroy the mutexes, we will not need them anymore.
         */
        mutex_destroy(&polled_input_device.polled_device_lock);

        mutex_destroy(&polled_output_device.polled_device_lock);
}

#if     defined(MAYBE_SOMETIME)
/*
 * Generic internal routine for registering a polled input or output device.
 */
/* ARGSUSED */
static void
polled_io_register(
cons_polledio_t                 *polled_io,
polled_io_console_type_t        type,
int                             flags
)
{
        switch (type) {
        case POLLED_IO_CONSOLE_INPUT:
                /*
                 * Grab the device lock, because we are going to access
                 * protected structure entries.  We do this before the
                 * POLLED_IO_CONSOLE_OPEN_INPUT so that we serialize
                 * registration.
                 */
                mutex_enter(&polled_input_device.polled_device_lock);

                /*
                 * Save the polled_io pointers so that we can access
                 * them later.
                 */
                polled_input_device.polled_io = polled_io;

                mutex_exit(&polled_input_device.polled_device_lock);

                /*
                 * Tell the generic console framework to
                 * repoint OBP's stdin to this keyboard device.
                 */
                (void) polled_io_take_console(type, 0);

                break;

        case POLLED_IO_CONSOLE_OUTPUT:
                /*
                 * Grab the device lock, because we are going to access
                 * protected structure entries. We do this before the
                 * POLLED_IO_CONSOLE_OPEN_OUTPUT so that we serialize
                 * registration.
                 */
                mutex_enter(&polled_output_device.polled_device_lock);

                /*
                 * Save the polled_io pointers so that we can access
                 * them later.
                 */
                polled_input_device.polled_io = polled_io;

                mutex_exit(&polled_output_device.polled_device_lock);

                break;
        }
}

/*
 * Generic internal routine for unregistering a polled input or output device.
 */
/* ARGSUSED */
static void
polled_io_unregister(
polled_io_console_type_t        type,
int                             flags
)
{
        switch (type) {
        case POLLED_IO_CONSOLE_INPUT:
                /*
                 * Tell the generic console framework to restore OBP's
                 * old stdin pointers.
                 */
                (void) polled_io_release_console(type, 0);

                /*
                 * Grab the device lock, because we are going to access
                 * protected structure entries.
                 */
                mutex_enter(&polled_input_device.polled_device_lock);

                /*
                 * We are closing the device, so get the value for the op
                 * pointer.  We use the polled_io structure to determine if
                 * there is a device registered,  so null the dev_ops
                 * structure.
                 */
                polled_input_device.polled_io = NULL;

                mutex_exit(&polled_input_device.polled_device_lock);

                break;

        case POLLED_IO_CONSOLE_OUTPUT:
                /*
                 * Grab the device lock, because we are going to access
                 * protected structure entries.
                 */
                mutex_enter(&polled_output_device.polled_device_lock);

                /*
                 * We are closing the device, so get the value for the op
                 * pointer.  We use the polled_io structure to determine if
                 * there is a device registered.
                 */
                polled_output_device.polled_io = NULL;

                mutex_exit(&polled_output_device.polled_device_lock);

                break;
        }
}

/*
 * This is the routine that is called to throw the switch from boot
 * ownership of stdout/stdin to the kernel.
 */
/* ARGSUSED */
static int
polled_io_take_console(
polled_io_console_type_t        type,
int                             flags
)
{
        switch (type) {
        case POLLED_IO_CONSOLE_INPUT:
                /*
                 * Perhaps this should be where we switch *sysp
                 */
                break;

        case POLLED_IO_CONSOLE_OUTPUT:
                /*
                 * Perhaps this should be where we switch *sysp
                 */
                break;
        }

        return (DDI_SUCCESS);
}

/*
 * This routine gives control of console input/output back to ???.
 *
 * Solaris/Intel has nobody to give it back to.  Hope we don't get here!
 */
/* ARGSUSED */
static int
polled_io_release_console(
polled_io_console_type_t        type,
int                             flags
)
{
        cmn_err(CE_WARN,
            "polled_io_release_console:  nobody to hand console back to");

        return (DDI_SUCCESS);
}

/*
 * This is the routine that kmdb calls to save any state information
 * before using the input device.  This routine, and all of the
 * routines that it calls, are responsible for saving any state
 * information so that it can be restored when polled mode is over.
 */
static void
polled_give_input(void)
{
        cons_polledio_t         *polled_io;

        /*
         * We check the dev_ops pointer to see if there is an
         * input device that has been registered.
         */
        polled_io = polled_input_device.polled_io;

        if (polled_io == NULL || polled_io->cons_polledio_enter == NULL) {
                return;
        }

        /*
         * Call down to the lower layers to save the state.
         */
        polled_io->cons_polledio_enter(
                polled_io->cons_polledio_argument);
}

/*
 * This is the routine that kmdb calls when it is giving up control of the
 * input device.  This routine, and the lower layer routines that it calls,
 * are responsible for restoring the controller state to the state it was
 * in before kmdb took control.
 */
static void
polled_take_input(void)
{
        cons_polledio_t         *polled_io;

        /*
         * We check the dev_ops pointer to see if there is an
         * input device that has been registered.
         */
        polled_io = polled_input_device.polled_io;

        if (polled_io == NULL || polled_io->cons_polledio_exit == NULL) {
                return;
        }

        /*
         * Call down to the lower layers to save the state.
         */
        polled_io->cons_polledio_exit(
                polled_io->cons_polledio_argument);
}

/*
 * This is the routine that kmdb calls to save any state information
 * before using the output device.  This routine, and all of the
 * routines that it calls, are responsible for saving any state
 * information so that it can be restored when polled mode is over.
 */
static void
polled_give_output()
{
        cons_polledio_t         *polled_io;

        /*
         * We check the dev_ops pointer to see if there is an
         * output device that has been registered.
         */
        polled_io = polled_output_device.polled_io;

        if (polled_io == NULL || polled_io->cons_polledio_enter == NULL) {
                return;
        }

        /*
         * Call down to the lower layers to save the state.
         */
        polled_io->cons_polledio_enter(
                polled_io->cons_polledio_argument);
}

/*
 * This is the routine that kmdb calls when it is giving up control of the
 * output device.  This routine, and the lower layer routines that it calls,
 * are responsible for restoring the controller state to the state it was
 * in before kmdb took control.
 */
static void
polled_take_output(void)
{
        cons_polledio_t         *polled_io;

        /*
         * We check the dev_ops pointer to see if there is an
         * output device that has been registered.
         */
        polled_io = polled_output_device.polled_io;

        if (polled_io == NULL || polled_io->cons_polledio_exit == NULL) {
                return;
        }

        /*
         * Call down to the lower layers to save the state.
         */
        polled_io->cons_polledio_exit(
                polled_io->cons_polledio_argument);
}
#endif  /* MAYBE_SOMETIME */