📄 io.c
字号:
/************************************************************************
*
* io.c
*
* The 'io' module implements a generic api for all device drivers.
* Through this interface all interaction between the user and the
* device driver is executed by use of a standard set of io-functions
* to:
*
* 1) init device,
* 2) open device,
* 3) close device,
* 4) read device,
* 5) write device,
* 6) ctrl device.
*
*
*
* ######################################################################
*
* Copyright (c) 1999-2000 MIPS Technologies, Inc. All rights reserved.
*
* Unpublished rights reserved under the Copyright Laws of the United States of
* America.
*
* This document contains information that is proprietary to MIPS Technologies,
* Inc. ("MIPS Technologies"). Any copying, modifying or use of this information
* (in whole or in part) which is not expressly permitted in writing by MIPS
* Technologies or a contractually-authorized third party is strictly
* prohibited. At a minimum, this information is protected under unfair
* competition laws and the expression of the information contained herein is
* protected under federal copyright laws. Violations thereof may result in
* criminal penalties and fines.
* MIPS Technologies or any contractually-authorized third party reserves the
* right to change the information contained in this document to improve
* function, design or otherwise. MIPS Technologies does not assume any
* liability arising out of the application or use of this information. Any
* license under patent rights or any other intellectual property rights owned
* by MIPS Technologies or third parties shall be conveyed by MIPS Technologies
* or any contractually-authorized third party in a separate license agreement
* between the parties.
* The information contained in this document constitutes one or more of the
* following: commercial computer software, commercial computer software
* documentation or other commercial items. If the user of this information, or
* any related documentation of any kind, including related technical data or
* manuals, is an agency, department, or other entity of the United States
* government ("Government"), the use, duplication, reproduction, release,
* modification, disclosure, or transfer of this information, or any related
* documentation of any kind, is restricted in accordance with Federal
* Acquisition Regulation 12.212 for civilian agencies and Defense Federal
* Acquisition Regulation Supplement 227.7202 for military agencies. The use of
* this information by the Government is further restricted in accordance with
* the terms of the license agreement(s) and/or applicable contract terms and
* conditions covering this information from MIPS Technologies or any
* contractually-authorized third party.
*
************************************************************************/
/************************************************************************
* Include files
************************************************************************/
#include "sysdefs.h"
#include "syserror.h"
#include "io_api.h"
#include "syscon_api.h"
/************************************************************************
* Definitions
************************************************************************/
/*
IO device entry definition
*/
typedef struct IO_device
{
t_io_service init ;
t_io_service open ;
t_io_service close ;
t_io_service read ;
t_io_service write ;
t_io_service ctrl ;
void *data ;
unsigned int state ;
} t_IO_device ;
/************************************************************************
* IO enumeration definitions
*************************************************************************/
/*
IO device entry states
*/
typedef enum IO_device_entry_state
{
IO_DEVICE_NOT_PRESENT = 0x42, /* IO device is not present */
IO_DEVICE_PRESENT = 0x4242, /* IO device has been installed */
} t_IO_device_entry_state ;
/************************************************************************
* Macro Definitions
*************************************************************************/
#define IO_CHECK_MAJOR( major, last ) \
if ( major > last ) \
{ \
return( ERROR_IO_ILLEGAL_MAJOR ) ; \
}
/************************************************************************
* Public variables
************************************************************************/
/************************************************************************
* Static variables
************************************************************************/
static t_IO_device *IO ; /* keeps the ref. for the IO device table */
static UINT32 last_device ; /* keeps the configured last device
number of the IO table.
(The size of the IO table is
'last_device'+1) */
/************************************************************************
* Static function prototypes
************************************************************************/
/************************************************************************
*
* IO_dummy_no_driver
* Description :
* -------------
*
* This is a dummy device driver service, which is inserted in each
* service entry of each allocated device in the IO device table.
* This will ensure a device service to be handled with a correct
* service completion ('ERROR_IO_NO_DRIVER') as default service.
*
*
* Parameters :
* ------------
*
* 'major', IN, major device number
* 'minor', IN, minor device number for multi device drivers
* 'p_param', INOUT, device specific parameter block
*
*
* Return values :
* ---------------
*
* 'ERROR_IO_NO_DRIVER': Driver not installed
*
************************************************************************/
static
INT32 IO_dummy_no_driver(
UINT32 major, /* IN: major device number */
UINT32 minor, /* IN: minor device number */
void *p_param ) ; /* INOUT: device parameter block */
/************************************************************************
*
* IO_dummy_no_service
* Description :
* -------------
*
* This is a dummy device driver service, which is the default service,
* for unsupported services of installed device drivers.
* This will ensure a device service to be handled with a correct
* service completion ('ERROR_IO_NO_SERVICE') as default service.
*
*
* Parameters :
* ------------
*
* 'major', IN, major device number
* 'minor', IN, minor device number for multi device drivers
* 'p_param', INOUT, device specific parameter block
*
*
* Return values :
* ---------------
*
* 'ERROR_IO_NO_SERVICE': Unsupported service
*
************************************************************************/
static
INT32 IO_dummy_no_service(
UINT32 major, /* IN: major device number */
UINT32 minor, /* IN: minor device number */
void *p_param ) ; /* INOUT: device parameter block */
/************************************************************************
* Implementation : Public functions
************************************************************************/
/************************************************************************
*
* IO_setup
* Description :
* -------------
*
* Initializes the 'IO' module.
*
*
*
*
* Parameters :
* ------------
*
* 'devices', IN, allocate space for max. 'devices' to be
* handled by the IO system
*
*
* Return values :
* ---------------
*
* 'OK'(=0)
* 'ERROR_IO_NO_SPACE': Not enough memory
*
************************************************************************/
INT32 IO_setup(
UINT32 devices ) /* IN: max. 'devices' to be supported */
{
t_sys_malloc mem ;
int i, rcode ;
/* calculate IO table size and allocate table */
mem.size = devices * sizeof(t_IO_device) ;
mem.boundary = 8 ; /* double long word */
mem.memory = (void**) &IO ;
rcode = SYSCON_read( SYSCON_BOARD_MALLOC_ID,
&mem,
sizeof(mem) ) ;
if (rcode != OK)
{
return( rcode ) ;
}
/* initialize io device table */
for (i=0; i<devices; i++)
{
IO[i].init = IO_dummy_no_driver ;
IO[i].open = IO_dummy_no_driver ;
IO[i].close = IO_dummy_no_driver ;
IO[i].read = IO_dummy_no_driver ;
IO[i].write = IO_dummy_no_driver ;
IO[i].ctrl = IO_dummy_no_driver ;
IO[i].data = NULL ;
IO[i].state = IO_DEVICE_NOT_PRESENT ;
}
/* save the configured number of devices */
last_device = devices - 1 ;
return( OK ) ;
}
/************************************************************************
*
* IO_install
* Description :
* -------------
*
* Installs the device drivers services in the IO system at the
* specified device slot, which is adressed with the 'major'
* device number. The service function pointers may be 'NULL',
* but at least one service must be supplied.
*
*
*
*
* Parameters :
* ------------
*
* 'major', IN, major device number
* 'init', IN, device drivers 'init' service function pointer
* 'open', IN, device drivers 'open' service function pointer
* 'close', IN, device drivers 'close' service function pointer
* 'read', IN, device drivers 'read' service function pointer
* 'write', IN, device drivers 'write' service function pointer
* 'ctrl', IN, device drivers 'ctrl' service function pointer
*
*
* Return values :
* ---------------
*
* 'OK'(=0)
* 'ERROR_IO_ILLEGAL_DEVICE': No device services are provided
* 'ERROR_IO_ILLEGAL_MAJOR': Illegal major device number
* 'ERROR_IO_NO_SPACE': Device slot already allocated
*
************************************************************************/
INT32 IO_install(
UINT32 major, /* IN: major device number */
t_io_service init, /* 'init' service function pointer */
t_io_service open, /* 'open' service function pointer */
t_io_service close, /* 'close' service function pointer */
t_io_service read, /* 'read' service function pointer */
t_io_service write, /* 'write' service function pointer */
t_io_service ctrl ) /* 'ctrl' service function pointer */
{
/* check for invalid major device number */
IO_CHECK_MAJOR( major, last_device ) ;
/* check, if device slot has been allocated by another driver */
if ( IO[major].state == IO_DEVICE_PRESENT )
{
return( ERROR_IO_NO_SPACE ) ;
}
/* check if any service present */
if ( (init == NULL) && (open == NULL) && (close == NULL) &&
(read == NULL) && (write == NULL) && (ctrl == NULL) )
{
return( ERROR_IO_ILLEGAL_DEVICE ) ;
}
/* if present, install 'init' service */
if ( init != NULL )
{
IO[major].init = init ;
}
else
{
IO[major].init = IO_dummy_no_service ;
}
/* if present, install 'open' service */
if ( open != NULL )
{
IO[major].open = open ;
}
else
{
IO[major].open = IO_dummy_no_service ;
}
/* if present, install 'close' service */
if ( close != NULL )
{
IO[major].close = close ;
}
else
{
IO[major].close = IO_dummy_no_service ;
}
/* if present, install 'read' service */
if ( read != NULL )
{
IO[major].read = read ;
}
else
{
IO[major].read = IO_dummy_no_service ;
}
/* if present, install 'write' service */
if ( write != NULL )
{
IO[major].write = write ;
}
else
{
IO[major].write = IO_dummy_no_service ;
}
/* if present, install 'ctrl' service */
if ( ctrl != NULL )
{
IO[major].ctrl = ctrl ;
}
else
{
IO[major].ctrl = IO_dummy_no_service ;
}
/* complete device installation */
IO[major].data = NULL ;
IO[major].state = IO_DEVICE_PRESENT ;
return( OK ) ;
}
/************************************************************************
*
* IO_init
* Description :
* -------------
*
* This function looks up the 'init' function of the driver by use of
* the 'major' device number and calls the 'init' function with the
* supplied parameters, 'minor' and 'p_param'.
*
*
* Parameters :
* ------------
*
* 'major', IN, major device number
* 'minor', IN, minor device number for multi device drivers
* 'p_param', INOUT, device specific parameter block
*
*
* Return values :
* ---------------
*
* 'OK'(=0)
* 'ERROR_IO_ILLEGAL_MAJOR': Illegal major device number
* 'ERROR_IO_NO_DRIVER': Driver not installed
* 'ERROR_IO_NO_FUNCTION': Driver don't implement 'init'
*
*
* Note :
* ------
* The return values above are the IO-system specific values only.
* Errors, which are specific for the device driver, may be returned too.
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -