disk.c

MIPS YAMON, a famous monitor inc. source, make file and PDF manuals.

/************************************************************************
 *
 *  disk.c
 *
 *  Monitor command for accessing IDE disks
 *
 *  disk [-f] (id [hda|hdb|hdc|hdd]                          ) |
 *            (read  hda|hdb|hdc|hdd <sector> <count> <addr> ) |
 *            (write hda|hdb|hdc|hdd <sector> <count> <addr> )
 *
 * ######################################################################
 *
 * mips_start_of_legal_notice
 * 
 * Copyright (c) 2004 MIPS Technologies, Inc. All rights reserved.
 *
 *
 * Unpublished rights (if any) reserved under the copyright laws of the
 * United States of America and other countries.
 *
 * This code is proprietary to MIPS Technologies, Inc. ("MIPS
 * Technologies"). Any copying, reproducing, modifying or use of this code
 * (in whole or in part) that is not expressly permitted in writing by MIPS
 * Technologies or an authorized third party is strictly prohibited. At a
 * minimum, this code is protected under unfair competition and copyright
 * laws. Violations thereof may result in criminal penalties and fines.
 *
 * MIPS Technologies reserves the right to change this code to improve
 * function, design or otherwise. MIPS Technologies does not assume any
 * liability arising out of the application or use of this code, or of any
 * error or omission in such code. Any warranties, whether express,
 * statutory, implied or otherwise, including but not limited to the implied
 * warranties of merchantability or fitness for a particular purpose, are
 * excluded. Except as expressly provided in any written license agreement
 * from MIPS Technologies or an authorized third party, the furnishing of
 * this code does not give recipient any license to any intellectual
 * property rights, including any patent rights, that cover this code.
 *
 * This code shall not be exported, reexported, transferred, or released,
 * directly or indirectly, in violation of the law of any country or
 * international law, regulation, treaty, Executive Order, statute,
 * amendments or supplements thereto. Should a conflict arise regarding the
 * export, reexport, transfer, or release of this code, the laws of the
 * United States of America shall be the governing law.
 *
 * This code constitutes one or more of the following: commercial computer
 * software, commercial computer software documentation or other commercial
 * items. If the user of this code, 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 code, 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 code 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 code from MIPS Technologies or an authorized
 * third party.
 *
 *
 *
 * 
 * mips_end_of_legal_notice
 * 
 *
 ************************************************************************/


/************************************************************************
 *  Include files
 ************************************************************************/

#include <sysdefs.h>
#include <sys_api.h>
#include <flash_api.h>
#include <io_api.h>
#include <ide_api.h>
#include <shell_api.h>
#include <shell.h>
#include <string.h>
#include <stdio.h>
#include <sysdev.h>

/************************************************************************
 *  Definitions
 ************************************************************************/

/* Number of sectors read/written for each '.' printed */
#define SECTORS_PER_DOT		100

/************************************************************************
 *  Public variables
 ************************************************************************/

/************************************************************************
 *  Static variables
 ************************************************************************/

/* OPTIONS */
static t_cmd_option options[] =
{
#define OPTION_FLUSH	0 
    { "f",  "Do not flush caches" }
};
#define OPTION_COUNT	(sizeof(options)/sizeof(t_cmd_option))

/************************************************************************
 *  Static function prototypes
 ************************************************************************/

static UINT32
get_options( 
    UINT32 argc,
    char   **argv,
    UINT32 *command,
    UINT32 *sector,
    UINT32 *count,
    UINT8  **addr,
    UINT32 *device,
    bool   *dev_all,
    bool   *flush );

static UINT32
do_access(
    t_ide_ctrl_descriptor *ide_ctrl,
    UINT8		  *addr,
    UINT32		  device,
    UINT32		  count );

/************************************************************************
 *  Implementation : Static functions
 ************************************************************************/
 

/************************************************************************
 *                          disk
 ************************************************************************/
static MON_FUNC(disk)
{
    UINT32                 rc = OK;
    UINT32		   device, count;
    UINT8		   *addr;
    bool		   dev_all, flush;
    t_ide_ctrl_descriptor  ide_ctrl;
    
    rc = get_options( argc, 
		      argv, 
		      &ide_ctrl.command,
		      &ide_ctrl.u.sector.sector,
		      &count,
		      &addr,
      		      &device,
		      &dev_all,
		      &flush );

    if( rc == OK )
    {
        /* Possibly flush caches */
        if( flush )
            sys_flush_caches();

        if( dev_all )
	{
	    rc = shell_ide_display();
	}
	else
	{
            rc = do_access( &ide_ctrl, addr, device, count );

            /* Possibly flush caches */
            if( (rc == OK) && flush )
                sys_flush_caches();
        }
    }

    return rc;
}


/************************************************************************
 *                          get_options
 ************************************************************************/
static UINT32
get_options( 
    UINT32 argc,
    char   **argv,
    UINT32 *command,
    UINT32 *sector,
    UINT32 *count,
    UINT8  **addr,
    UINT32 *device,
    bool   *dev_all,
    bool   *flush )
{
    t_shell_option decode;
    UINT32	   type;
    UINT32	   arg;
    UINT32	   int_count = 0;
    bool	   dev_valid = FALSE;
    bool	   cmd_valid = FALSE;
    UINT32	   rc	     = OK;

    /* Defaults */
    *flush = TRUE;

    for( arg = 1; 
	          (rc == OK) && 
	          (arg < argc) && 
                  shell_decode_token( argv[arg], &type, &decode );
         arg++ )
    {
	switch( type )
	{
	  case SHELL_TOKEN_OPTION :
	    if( strcmp(decode.option, options[OPTION_FLUSH].option) == 0 )
	    {
	        *flush = FALSE;
	    }
	    else
	    {
	        rc 	         = SHELL_ERROR_OPTION;
	        shell_error_data = argv[arg];
	    }
	    break;
	  case SHELL_TOKEN_NUMBER :
	    if( int_count == 3 )
	        rc = SHELL_ERROR_SYNTAX;
	    else
	    {
	        switch( int_count )
	        {
	          case 0 : *sector = decode.number;	     break;
	          case 1 : *count  = decode.number;	     break;
	          case 2 : *addr   = (UINT8 *)decode.number; break;
	        }

	        int_count++;
	    }
	    break;
	  case SHELL_TOKEN_STRING :
	    if(      strcmp( decode.string, "hda" ) == 0 )
	    {
	        *device   = IDE_MINOR_PRIMARY_MASTER;
		dev_valid = TRUE;
	    }
	    else if( strcmp( decode.string, "hdb" ) == 0 )
	    {
	        *device   = IDE_MINOR_PRIMARY_SLAVE;
		dev_valid = TRUE;
	    }
	    else if( strcmp( decode.string, "hdc" ) == 0 )
	    {	    
	        *device   = IDE_MINOR_SECONDARY_MASTER;
		dev_valid = TRUE;
	    }
	    else if( strcmp( decode.string, "hdd" ) == 0 )
	    {
	        *device   = IDE_MINOR_SECONDARY_SLAVE;
		dev_valid = TRUE;
	    }
	    else if( strcmp( decode.string, "id" ) == 0 )
	    {
	        *command  = IDE_CMD_IDENTIFY;
		cmd_valid = TRUE;
	    }
	    else if( strcmp( decode.string, "read" ) == 0 )
	    {
	        *command  = IDE_CMD_READ;
		cmd_valid = TRUE;
	    }
	    else if( strcmp( decode.string, "write" ) == 0 )
	    {
	        *command  = IDE_CMD_WRITE;
		cmd_valid = TRUE;
	    }
	    else 
	        rc = SHELL_ERROR_SYNTAX;
	    break;
	  default :
            rc = SHELL_ERROR_SYNTAX;
	    break;
        }
    }

    if( rc != OK )
        return rc;

    if( !cmd_valid )
        return SHELL_ERROR_SYNTAX;
   
    switch( *command )
    {