polled_io.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* 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
* 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/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.
*
* 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.
*/
/*
* Initialize lock to protect multiple thread access to the
* polled_output_device structure. This does not protect
* us from access in OBP mode.
*/
}
/*
* 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
int flags
)
{
#if defined(MAYBE_SOMETIME)
/*
* If the input structure entries are filled in, then register this
* structure as an input device.
*/
}
/*
* If the output structure entries are filled in, then register this
* structure as an output device.
*/
}
#else
#endif
return (DDI_SUCCESS);
}
/*
*/
int
int flags
)
{
#if defined(MAYBE_SOMETIME)
/*
* If polled_io is being used for input, then unregister it.
*/
}
/*
* If polled_io is being used for output, then unregister it.
*/
}
#else
#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
{
/*
* Destroy the mutexes, we will not need them anymore.
*/
}
#if defined(MAYBE_SOMETIME)
/*
* Generic internal routine for registering a polled input or output device.
*/
/* ARGSUSED */
static void
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.
*/
/*
* Save the polled_io pointers so that we can access
* them later.
*/
/*
* 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.
*/
/*
* Save the polled_io pointers so that we can access
* them later.
*/
break;
}
}
/*
* Generic internal routine for unregistering a polled input or output device.
*/
/* ARGSUSED */
static void
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.
*/
/*
* 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.
*/
break;
case POLLED_IO_CONSOLE_OUTPUT:
/*
* Grab the device lock, because we are going to access
* protected structure entries.
*/
/*
* 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.
*/
break;
}
}
/*
* This is the routine that is called to throw the switch from boot
*/
/* ARGSUSED */
static int
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);
}
/*
*
*/
/* ARGSUSED */
static int
int flags
)
{
"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)
{
/*
* We check the dev_ops pointer to see if there is an
* input device that has been registered.
*/
return;
}
/*
* Call down to the lower layers to save the state.
*/
}
/*
* 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)
{
/*
* We check the dev_ops pointer to see if there is an
* input device that has been registered.
*/
return;
}
/*
* Call down to the lower layers to save the state.
*/
}
/*
* 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
{
/*
* We check the dev_ops pointer to see if there is an
* output device that has been registered.
*/
return;
}
/*
* Call down to the lower layers to save the state.
*/
}
/*
* 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)
{
/*
* We check the dev_ops pointer to see if there is an
* output device that has been registered.
*/
return;
}
/*
* Call down to the lower layers to save the state.
*/
}
#endif /* MAYBE_SOMETIME */