/*      -*- linux-c -*-
 *
 * Copyright (c) 2008 Pigeon Point Systems.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  This
 * file and program are licensed under a BSD style license.  See
 * the Copying file included with the OpenHPI distribution for
 * full licensing terms.
 *
 * Author(s):
 *    Anton Pak    <anton.pak@pigeonpoint.com>
 *
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "hpi_ui.h"
#include "hpi_cmd.h"

typedef struct {
    SaHpiResourceIdT     rptid;
    SaHpiFumiNumT        fuminum;
    SaHpiFumiCapabilityT fumicaps;
} fumi_block_env_t;

static fumi_block_env_t fumi_block_env;

static ret_code_t get_banknum_prompt( char * prompt, SaHpiBankNumT * banknum )
{
    int i, res;

    i = get_int_param( prompt, &res );
    if ( i != 1 ) {
        printf( "Error!!! Invalid Bank Num\n" );
        return HPI_SHELL_PARM_ERROR ;
    }
    *banknum = (SaHpiBankNumT)res;
    return HPI_SHELL_OK;
}

static ret_code_t get_banknum( SaHpiBankNumT * banknum )
{
    return get_banknum_prompt( "Bank Num(0 == active bank): ", banknum );
}

static ret_code_t get_position( SaHpiUint32T * position )
{
    int i, res;

    i = get_int_param( "Position of the bank in boot order: ", &res );
    if ( i != 1 ) {
        printf( "Error!!! Invalid position\n" );
        return HPI_SHELL_PARM_ERROR ;
    }
    *position = (SaHpiUint32T)res;
    return HPI_SHELL_OK;
}

static ret_code_t get_uri( SaHpiTextBufferT* uri )
{
    int i;

    i = get_string_param("Source URI: ", (char*)(uri->Data), SAHPI_MAX_TEXT_BUFFER_LENGTH);
    if ( i != 0 ) {
        printf( "Error!!! Invalid string: %s\n", uri->Data );
        return HPI_SHELL_PARM_ERROR ;
    }
    uri->DataType   = SAHPI_TL_TYPE_TEXT;
    uri->Language   = SAHPI_LANG_ENGLISH;
    uri->DataLength = strlen( (char*)(uri->Data) );
    return HPI_SHELL_OK;
}

static void show_fw_info( const char * fwname,
                          const char * indent,
                          SaHpiFumiFirmwareInstanceInfoT * fwinfo )
{
    printf( "%s", indent );
    printf( "%s Present: %s\n", fwname, ( fwinfo->InstancePresent == SAHPI_FALSE ) ? "FALSE" : "TRUE" );
    if ( fwinfo->InstancePresent != SAHPI_FALSE ) {
        printf( "%s    ", indent );
        print_text_buffer_text( "Identifier: \"",
                                &fwinfo->Identifier,
                                "\"\n",
                                ui_print );
        printf( "%s    ", indent );
        print_text_buffer_text( "Description: \"",
                                &fwinfo->Description,
                                "\"\n",
                                ui_print );
        printf( "%s    ", indent );
        print_text_buffer_text( "DateTime: \"",
                                &fwinfo->DateTime,
                                "\"\n",
                                ui_print );
        printf( "%s    ", indent );
        printf( "Version: %u.%u.%u\n", fwinfo->MajorVersion, fwinfo->MinorVersion, fwinfo->AuxVersion );
    }
}

static void show_component_info( const char * indent, SaHpiFumiComponentInfoT * cinfo )
{
    char fw_info_indent[256];

    printf( "%s", indent );
    printf( "Component %u\n", cinfo->ComponentId );
    strncpy( fw_info_indent, indent, sizeof(fw_info_indent) );
    strncat( fw_info_indent, "    ", sizeof(fw_info_indent) );
    show_fw_info( "Main Instance", fw_info_indent, &cinfo->MainFwInstance );
    printf( "%s    ", indent );
    printf( "ComponentFlags 0x%x\n", cinfo->ComponentFlags );
}


static ret_code_t show_spec_info( SaHpiSessionIdT sessionId,
                                  SaHpiResourceIdT rptid,
                                  SaHpiFumiNumT fuminum )
{
    SaErrorT rv;
    SaHpiFumiSpecInfoT info;

    rv = saHpiFumiSpecInfoGet( sessionId, rptid, fuminum, &info );
    if ( rv != SA_OK ) {
        printf( "ERROR!!! saHpiFumiSpecInfoGet: %s\n", oh_lookup_error( rv ) );
        return HPI_SHELL_CMD_ERROR;
    }

    printf( "SpecInfo Type: %s\n", oh_lookup_fumispecinfotype( info.SpecInfoType ) );
    switch ( info.SpecInfoType ) {
        case SAHPI_FUMI_SPEC_INFO_NONE:
            break;
        case SAHPI_FUMI_SPEC_INFO_SAF_DEFINED:
            printf( "    Spec ID: %s\n",
                    oh_lookup_fumisafdefinedspecid( info.SpecInfoTypeUnion.SafDefined.SpecID ) );
            printf( "    Revision ID: %u\n", info.SpecInfoTypeUnion.SafDefined.RevisionID );
            break;
        case SAHPI_FUMI_SPEC_INFO_OEM_DEFINED:
            {
                unsigned int i;
                SaHpiTextBufferT tb_mid;

                rv = oh_decode_manufacturerid( info.SpecInfoTypeUnion.OemDefined.Mid, &tb_mid );
                if ( rv != SA_OK ) {
                    printf( "ERROR!!! oh_decode_manufacturerid: %s\n", oh_lookup_error( rv ) );
                    return HPI_SHELL_CMD_ERROR;
                }
                print_text_buffer_text( "    Manufacturer ID: ",
                                        &tb_mid,
                                       "\n",
                                       ui_print );
                printf( "    Body:" );
                for ( i = 0; i < info.SpecInfoTypeUnion.OemDefined.BodyLength; ++i ) {
                    printf( " %02x", info.SpecInfoTypeUnion.OemDefined.Body[i] );
                }
                printf( " (len=%u)\n", i );
            }
            break;
        default:
            printf( "Unknown SpecInfo Type\n" );
            return HPI_SHELL_CMD_ERROR;
    }

    return HPI_SHELL_OK;
}

static ret_code_t show_service_impact( SaHpiSessionIdT sessionId,
                                       SaHpiResourceIdT rptid,
                                       SaHpiFumiNumT fuminum )
{
    unsigned int i;
    SaErrorT rv;
    SaHpiFumiServiceImpactDataT si;

    rv = saHpiFumiServiceImpactGet( sessionId, rptid, fuminum, &si );
    if ( rv != SA_OK ) {
        printf( "ERROR!!! saHpiFumiServiceImpactGet: %s\n", oh_lookup_error( rv ) );
        return HPI_SHELL_CMD_ERROR;
    }

    if ( si.NumEntities == 0 ) {
        printf( "No Service Impact\n" );
        return HPI_SHELL_OK;
    }

    printf( "Service Impact:\n" );
    for ( i = 0; i < si.NumEntities && i < SAHPI_FUMI_MAX_ENTITIES_IMPACTED; ++i ) {
        oh_big_textbuffer tmpbuf;

        oh_init_bigtext(&tmpbuf);
        rv = oh_decode_entitypath( &si.ImpactedEntities[i].ImpactedEntity, &tmpbuf );
        if ( rv != SA_OK ) {
            printf( "ERROR!!! oh_decode_entitypath: %s\n", oh_lookup_error( rv ) );
            return HPI_SHELL_CMD_ERROR;
        }
        printf( "    " );
        fwrite( tmpbuf.Data, tmpbuf.DataLength, 1, stdout );
        printf( ": %s\n", oh_lookup_fumiserviceimpact( si.ImpactedEntities[i].ServiceImpact ) );
    }
    return HPI_SHELL_OK;
}
static ret_code_t set_source( SaHpiSessionIdT sessionId,
                              SaHpiResourceIdT rptid,
                              SaHpiFumiNumT fuminum,
                              SaHpiBankNumT banknum,
                              SaHpiTextBufferT* uri )
{
    SaErrorT rv;

    rv = saHpiFumiSourceSet( sessionId, rptid, fuminum, banknum, uri );
    if ( rv != SA_OK ) {
        printf( "ERROR!!! saHpiFumiSourceSet: %s\n", oh_lookup_error( rv ) );
        return HPI_SHELL_CMD_ERROR;
    }
    return HPI_SHELL_OK;
}

static ret_code_t start_source_validation( SaHpiSessionIdT sessionId,
                                           SaHpiResourceIdT rptid,
                                           SaHpiFumiNumT fuminum,
                                           SaHpiBankNumT banknum )
{
    SaErrorT rv;

    rv = saHpiFumiSourceInfoValidateStart( sessionId, rptid, fuminum, banknum );
    if ( rv != SA_OK ) {
        printf( "ERROR!!! saHpiFumiSourceInfoValidateStart: %s\n", oh_lookup_error( rv ) );
        return HPI_SHELL_CMD_ERROR;
    }
    return HPI_SHELL_OK;
}

static ret_code_t show_source_info( SaHpiSessionIdT sessionId,
                                    SaHpiResourceIdT rptid,
                                    SaHpiFumiNumT fuminum,
                                    SaHpiBankNumT banknum )
{
    SaErrorT rv;
    SaHpiFumiSourceInfoT info;

    rv = saHpiFumiSourceInfoGet( sessionId, rptid, fuminum, banknum, &info );
    if ( rv != SA_OK ) {
        printf( "ERROR!!! saHpiFumiSourceInfoGet: %s\n", oh_lookup_error( rv ) );
        return HPI_SHELL_CMD_ERROR;
    }

    printf( "Bank Num: %d\n", banknum );
    print_text_buffer_text( "    Source URI: \"", &info.SourceUri, "\"\n", ui_print );
    printf( "    Source status: %s\n", oh_lookup_fumisourcestatus(  info.SourceStatus ) );
    print_text_buffer_text( "    Identifier: \"", &info.Identifier, "\"\n", ui_print );
    print_text_buffer_text( "    Description: \"", &info.Description, "\"\n", ui_print );
    print_text_buffer_text( "    DateTime: \"", &info.DateTime, "\"\n", ui_print );
    printf( "    Version: %u.%u.%u\n", info.MajorVersion, info.MinorVersion, info.AuxVersion );

    return HPI_SHELL_OK;
}

static ret_code_t show_source_component_info( SaHpiSessionIdT sessionId,
                                              SaHpiResourceIdT rptid,
                                              SaHpiFumiNumT fuminum,
                                              SaHpiBankNumT banknum )
{
    SaErrorT rv;
    SaHpiEntryIdT id = SAHPI_FIRST_ENTRY, next_id;
    SaHpiFumiComponentInfoT cinfo;

    while ( id != SAHPI_LAST_ENTRY ) {
        rv = saHpiFumiSourceComponentInfoGet( sessionId, rptid, fuminum,
                                              banknum, id, &next_id, &cinfo );
        if ( rv == SA_ERR_HPI_NOT_PRESENT ) {
            break;
        } else if ( rv != SA_OK ) {
            printf( "ERROR!!! saHpiFumiSourceComponentInfoGet: %s\n", oh_lookup_error( rv ) );
            return HPI_SHELL_CMD_ERROR;
        }
        show_component_info( "    ", &cinfo );

        id = next_id;
    }

    return HPI_SHELL_OK;
}

static ret_code_t show_bank_info( SaHpiSessionIdT sessionId,
                                    SaHpiResourceIdT rptid,
                                    SaHpiFumiNumT fuminum,
                                    SaHpiBankNumT banknum )
{
    SaErrorT rv;
    SaHpiFumiBankInfoT info;

    rv = saHpiFumiTargetInfoGet( sessionId, rptid, fuminum, banknum, &info );
    if ( rv != SA_OK ) {
        printf( "ERROR!!! saHpiFumiTargetInfoGet: %s\n", oh_lookup_error( rv ) );
        return HPI_SHELL_CMD_ERROR;
    }

    printf( "Bank Num: %d\n", banknum );
    printf( "    Bank id: %u\n", (unsigned int)info.BankId );
    printf( "    Bank size: %u KB\n", info.BankSize );
    printf( "    Position: %u\n", info.Position );
    printf( "    Bank state: %s\n", oh_lookup_fumibankstate( info.BankState ) );
    print_text_buffer_text( "    Identifier: \"", &info.Identifier, "\"\n", ui_print );
    print_text_buffer_text( "    Description: \"", &info.Description, "\"\n", ui_print );
    print_text_buffer_text( "    DateTime: \"", &info.DateTime, "\"\n", ui_print );
    printf( "    Version: %u.%u.%u\n", info.MajorVersion, info.MinorVersion, info.AuxVersion );

    return HPI_SHELL_OK;
}

static ret_code_t show_logical_bank_info( SaHpiSessionIdT sessionId,
                                          SaHpiResourceIdT rptid,
                                          SaHpiFumiNumT fuminum )
{
    SaErrorT rv;
    SaHpiFumiLogicalBankInfoT linfo;

    rv = saHpiFumiLogicalTargetInfoGet( sessionId, rptid, fuminum, &linfo );
    if ( rv != SA_OK ) {
        printf( "ERROR!!! saHpiFumiLogicalTargetInfoGet: %s\n", oh_lookup_error( rv ) );
        return HPI_SHELL_CMD_ERROR;
    }

    printf( "Logical Bank Information:\n" );
    printf( "    Firmware Persistent Location Count: %u\n", linfo.FirmwarePersistentLocationCount );
    printf( "    Bank State Flags:" );
    if ( linfo.BankStateFlags & SAHPI_FUMI_NO_MAIN_PERSISTENT_COPY ) {
        printf( "NO_MAIN_PERSISTENT_COPY" );
    }
    printf( "\n" );
    show_fw_info( "Pending Instance", "    ", &linfo.PendingFwInstance );
    show_fw_info( "Rollback Instance", "    ", &linfo.RollbackFwInstance );

    return HPI_SHELL_OK;
}

static ret_code_t show_bank_component_info( SaHpiSessionIdT sessionId,
                                            SaHpiResourceIdT rptid,
                                            SaHpiFumiNumT fuminum,
                                            SaHpiBankNumT banknum )
{
    SaErrorT rv;
    SaHpiEntryIdT id = SAHPI_FIRST_ENTRY, next_id;
    SaHpiFumiComponentInfoT cinfo;

    while ( id != SAHPI_LAST_ENTRY ) {
        rv = saHpiFumiTargetComponentInfoGet( sessionId, rptid, fuminum,
                                              banknum, id, &next_id, &cinfo );
        if ( rv != SA_OK ) {
            printf( "ERROR!!! saHpiFumiTargetComponentInfoGet: %s\n", oh_lookup_error( rv ) );
            return HPI_SHELL_CMD_ERROR;
        }

        show_component_info( "    ", &cinfo );

        id = next_id;
    }

    return HPI_SHELL_OK;
}

static ret_code_t show_logical_bank_component_info( SaHpiSessionIdT sessionId,
                                                    SaHpiResourceIdT rptid,
                                                    SaHpiFumiNumT fuminum )
{
    SaErrorT rv;
    SaHpiEntryIdT id = SAHPI_FIRST_ENTRY, next_id;

    SaHpiFumiLogicalComponentInfoT lcinfo;

    while ( id != SAHPI_LAST_ENTRY ) {
        rv = saHpiFumiLogicalTargetComponentInfoGet( sessionId, rptid, fuminum, id, &next_id, &lcinfo );
        if ( rv != SA_OK ) {
            printf( "ERROR!!! saHpiFumiLogicalTargetComponentInfoGet: %s\n", oh_lookup_error( rv ) );
            return HPI_SHELL_CMD_ERROR;
        }

        printf( "    Component %u\n", lcinfo.ComponentId );
        show_fw_info( "Pending Instance", "        ", &lcinfo.PendingFwInstance );
        show_fw_info( "Rollback Instance", "        ", &lcinfo.RollbackFwInstance );
        printf( "        ComponentFlags 0x%x\n", lcinfo.ComponentFlags );

        id = next_id;
    }

    return HPI_SHELL_OK;
}

static ret_code_t start_backup( SaHpiSessionIdT sessionId,
                                SaHpiResourceIdT rptid,
                                SaHpiFumiNumT fuminum )
{
    SaErrorT rv;

    rv = saHpiFumiBackupStart( sessionId, rptid, fuminum );
    if ( rv != SA_OK ) {
        printf( "ERROR!!! saHpiFumiBackupStart: %s\n", oh_lookup_error( rv ) );
        return HPI_SHELL_CMD_ERROR;
    }
    return HPI_SHELL_OK;
}

static ret_code_t set_bank_boot_order( SaHpiSessionIdT sessionId,
                                       SaHpiResourceIdT rptid,
                                       SaHpiFumiNumT fuminum,
                                       SaHpiBankNumT banknum,
                                       SaHpiUint32T position )
{
    SaErrorT rv;

    rv = saHpiFumiBankBootOrderSet( sessionId, rptid, fuminum, banknum, position );
    if ( rv != SA_OK ) {
        printf( "ERROR!!! saHpiFumiBankBootOrderSet: %s\n", oh_lookup_error( rv ) );
        return HPI_SHELL_CMD_ERROR;
    }
    return HPI_SHELL_OK;
}

static ret_code_t start_bank_copying( SaHpiSessionIdT sessionId,
                                      SaHpiResourceIdT rptid,
                                      SaHpiFumiNumT fuminum,
                                      SaHpiBankNumT srcbanknum,
                                      SaHpiBankNumT dstbanknum )
{
    SaErrorT rv;

    rv = saHpiFumiBankCopyStart( sessionId, rptid, fuminum, srcbanknum, dstbanknum );
    if ( rv != SA_OK ) {
        printf( "ERROR!!! saHpiFumiBankCopyStart: %s\n", oh_lookup_error( rv ) );
        return HPI_SHELL_CMD_ERROR;
    }
    return HPI_SHELL_OK;
}

static ret_code_t start_install( SaHpiSessionIdT sessionId,
                                 SaHpiResourceIdT rptid,
                                 SaHpiFumiNumT fuminum,
                                 SaHpiBankNumT banknum )
{
    SaErrorT rv;

    rv = saHpiFumiInstallStart( sessionId, rptid, fuminum, banknum );
    if ( rv != SA_OK ) {
        printf( "ERROR!!! saHpiFumiInstallStart: %s\n", oh_lookup_error( rv ) );
        return HPI_SHELL_CMD_ERROR;
    }
    return HPI_SHELL_OK;
}

static ret_code_t show_upgrade_status( SaHpiSessionIdT sessionId,
                                       SaHpiResourceIdT rptid,
                                       SaHpiFumiNumT fuminum,
                                       SaHpiBankNumT banknum )
{
    SaErrorT rv;
    SaHpiFumiUpgradeStatusT status;

    rv = saHpiFumiUpgradeStatusGet( sessionId, rptid, fuminum, banknum, &status );
    if ( rv != SA_OK ) {
        printf( "ERROR!!! saHpiFumiUpgradeStatusGet: %s\n", oh_lookup_error( rv ) );
        return HPI_SHELL_CMD_ERROR;
    }

    printf( "Upgrade status on bank %d: %s\n", banknum, oh_lookup_fumiupgradestatus( status ) );

    return HPI_SHELL_OK;
}

static ret_code_t start_target_verification( SaHpiSessionIdT sessionId,
                                             SaHpiResourceIdT rptid,
                                             SaHpiFumiNumT fuminum,
                                             SaHpiBankNumT banknum )
{
    SaErrorT rv;

    rv = saHpiFumiTargetVerifyStart( sessionId, rptid, fuminum, banknum );
    if ( rv != SA_OK ) {
        printf( "ERROR!!! saHpiFumiTargetVerifyStart: %s\n", oh_lookup_error( rv ) );
        return HPI_SHELL_CMD_ERROR;
    }
    return HPI_SHELL_OK;
}

static ret_code_t start_main_target_verification( SaHpiSessionIdT sessionId,
                                                  SaHpiResourceIdT rptid,
                                                  SaHpiFumiNumT fuminum )
{
    SaErrorT rv;

    rv = saHpiFumiTargetVerifyMainStart( sessionId, rptid, fuminum );
    if ( rv != SA_OK ) {
        printf( "ERROR!!! saHpiFumiTargetVerifyMainStart: %s\n", oh_lookup_error( rv ) );
        return HPI_SHELL_CMD_ERROR;
    }
    return HPI_SHELL_OK;
}

static ret_code_t cancel_upgrade( SaHpiSessionIdT sessionId,
                                  SaHpiResourceIdT rptid,
                                  SaHpiFumiNumT fuminum,
                                  SaHpiBankNumT banknum )
{
    SaErrorT rv;

    rv = saHpiFumiUpgradeCancel( sessionId, rptid, fuminum, banknum );
    if ( rv != SA_OK ) {
        printf( "ERROR!!! saHpiFumiUpgradeCancel: %s\n", oh_lookup_error( rv ) );
        return HPI_SHELL_CMD_ERROR;
    }
    return HPI_SHELL_OK;
}

static ret_code_t show_autorollback_disable( SaHpiSessionIdT sessionId,
                                             SaHpiResourceIdT rptid,
                                             SaHpiFumiNumT fuminum )
{
    SaErrorT rv;
    SaHpiBoolT disable;

    rv = saHpiFumiAutoRollbackDisableGet( sessionId, rptid, fuminum, &disable );
    if ( rv != SA_OK ) {
        printf( "ERROR!!! saHpiFumiAutoRollbackDisableGet: %s\n", oh_lookup_error( rv ) );
        return HPI_SHELL_CMD_ERROR;
    }
    printf( "Auto Rollback Disabled: %s\n", ( disable == SAHPI_FALSE ) ? "FALSE" : "TRUE" );

    return HPI_SHELL_OK;
}

static ret_code_t set_autorollback_disable( SaHpiSessionIdT sessionId,
                                            SaHpiResourceIdT rptid,
                                            SaHpiFumiNumT fuminum,
                                            SaHpiBoolT disable )
{
    SaErrorT rv;

    rv = saHpiFumiAutoRollbackDisableSet( sessionId, rptid, fuminum, disable );
    if ( rv != SA_OK ) {
        printf( "ERROR!!! saHpiFumiAutoRollbackDisableSet: %s\n", oh_lookup_error( rv ) );
        return HPI_SHELL_CMD_ERROR;
    }
    printf( "Automatic Rollback %s successfully\n",
            ( disable == SAHPI_FALSE ) ? "enabled" : "disabled" );

    return HPI_SHELL_OK;
}

static ret_code_t start_rollback( SaHpiSessionIdT sessionId,
                                  SaHpiResourceIdT rptid,
                                  SaHpiFumiNumT fuminum )
{
    SaErrorT rv;

    rv = saHpiFumiRollbackStart( sessionId, rptid, fuminum );
    if ( rv != SA_OK ) {
        printf( "ERROR!!! saHpiFumiRollbackStart: %s\n", oh_lookup_error( rv ) );
        return HPI_SHELL_CMD_ERROR;
    }
    return HPI_SHELL_OK;
}

static ret_code_t activate( SaHpiSessionIdT sessionId,
                            SaHpiResourceIdT rptid,
                            SaHpiFumiNumT fuminum,
                            SaHpiBoolT logical )
{
    SaErrorT rv;

    rv = saHpiFumiActivateStart( sessionId, rptid, fuminum, logical );
    if ( rv != SA_OK ) {
        printf( "ERROR!!! saHpiFumiActivateStart: %s\n", oh_lookup_error( rv ) );
        return HPI_SHELL_CMD_ERROR;
    }
    return HPI_SHELL_OK;
}

static ret_code_t cleanup( SaHpiSessionIdT sessionId,
                           SaHpiResourceIdT rptid,
                           SaHpiFumiNumT fuminum,
                           SaHpiBankNumT banknum )
{
    SaErrorT rv;

    rv = saHpiFumiCleanup( sessionId, rptid, fuminum, banknum );
    if ( rv != SA_OK ) {
        printf( "ERROR!!! saHpiFumiCleanup: %s\n", oh_lookup_error( rv ) );
        return HPI_SHELL_CMD_ERROR;
    }
    return HPI_SHELL_OK;
}

/*************************************
 * commands
 ************************************/

ret_code_t fumi_block( void )
{
    SaErrorT           rv;
    ret_code_t         ret;
    SaHpiResourceIdT   rptid;
    SaHpiInstrumentIdT rdrnum;
    SaHpiRdrT          rdr;

    ret = ask_rpt( &rptid );
    if ( ret != HPI_SHELL_OK ) {
        return ret;
    };
    ret = ask_rdr( rptid, SAHPI_FUMI_RDR, &rdrnum );
    if ( ret != HPI_SHELL_OK ) {
        return ret;
    }
    rv = saHpiRdrGetByInstrumentId( Domain->sessionId, rptid, SAHPI_FUMI_RDR, rdrnum, &rdr );
    if ( rv != SA_OK ) {
        printf( "ERROR!!! saHpiRdrGetByInstrumentId"
                "(Rpt=%d RdrType=%d Rdr=%d): %s\n",
                rptid, SAHPI_FUMI_RDR, rdrnum,
                oh_lookup_error( rv )
              );
        return HPI_SHELL_CMD_ERROR;
    };

    fumi_block_env.rptid    = rptid;
    fumi_block_env.fuminum  = rdr.RdrTypeUnion.FumiRec.Num;
    fumi_block_env.fumicaps = rdr.RdrTypeUnion.FumiRec.Capability;

    block_type = FUMI_COM;
    for ( ;; ) {
        int res;
        term_def_t * term ;
        char buf[256];

        res = get_new_command( "FUMI block ==> " );
        if ( res == 2 ) {
            unget_term();
            break;
        };
        term = get_next_term();
        if ( term == NULL ) continue;
        snprintf( buf, 256, "%s", term->term );
        if ( ( strcmp( buf, "q" ) == 0) || ( strcmp( buf, "quit" ) == 0 ) ) {
            break;
        }
    }
    block_type = MAIN_COM;
    return HPI_SHELL_OK;
}

ret_code_t fumi_block_specinfo(void)
{
    return show_spec_info( Domain->sessionId,
                           fumi_block_env.rptid,
                           fumi_block_env.fuminum );
}

ret_code_t fumi_block_serviceimpact(void)
{
    return show_service_impact( Domain->sessionId,
                                fumi_block_env.rptid,
                                fumi_block_env.fuminum );
}

ret_code_t fumi_block_setsource(void)
{
    SaHpiBankNumT banknum;
    SaHpiTextBufferT uri;

    if ( get_banknum( &banknum) != HPI_SHELL_OK ) {
        return HPI_SHELL_PARM_ERROR;
    }
    if ( get_uri( &uri) != HPI_SHELL_OK ) {
        return HPI_SHELL_PARM_ERROR;
    }

    return set_source( Domain->sessionId,
                       fumi_block_env.rptid,
                       fumi_block_env.fuminum,
                       banknum,
                       &uri );
}

ret_code_t fumi_block_validatesource(void)
{
    SaHpiBankNumT banknum;

    if ( get_banknum( &banknum) != HPI_SHELL_OK ) {
        return HPI_SHELL_PARM_ERROR;
    }

    return start_source_validation( Domain->sessionId,
                                    fumi_block_env.rptid,
                                    fumi_block_env.fuminum,
                                    banknum );
}

ret_code_t fumi_block_sourceinfo(void)
{
    ret_code_t rc;
    SaHpiBankNumT banknum;

    if ( get_banknum( &banknum) != HPI_SHELL_OK ) {
        return HPI_SHELL_PARM_ERROR;
    }

    rc = show_source_info( Domain->sessionId,
                           fumi_block_env.rptid,
                           fumi_block_env.fuminum,
                           banknum );
    if ( rc != HPI_SHELL_OK ) {
        return rc;
    }
    if ( fumi_block_env.fumicaps & SAHPI_FUMI_CAP_COMPONENTS ) {
        rc = show_source_component_info( Domain->sessionId,
                                         fumi_block_env.rptid,
                                         fumi_block_env.fuminum,
                                         banknum );
    }

    return rc;
}

ret_code_t fumi_block_targetinfo(void)
{
    ret_code_t rc;
    SaHpiBankNumT banknum;

    if ( get_banknum( &banknum) != HPI_SHELL_OK ) {
        return HPI_SHELL_PARM_ERROR;
    }

    rc = show_bank_info( Domain->sessionId,
                         fumi_block_env.rptid,
                         fumi_block_env.fuminum,
                         banknum
                       );
    if ( rc != HPI_SHELL_OK ) {
        return rc;
    }

    if ( fumi_block_env.fumicaps & SAHPI_FUMI_CAP_COMPONENTS ) {
        rc = show_bank_component_info( Domain->sessionId,
                                       fumi_block_env.rptid,
                                       fumi_block_env.fuminum,
                                       banknum );
        if ( rc != HPI_SHELL_OK ) {
            return rc;
        }
    }

    if ( banknum == 0 ) {
        rc = show_logical_bank_info( Domain->sessionId,
                                     fumi_block_env.rptid,
                                     fumi_block_env.fuminum );
        if ( rc != HPI_SHELL_OK ) {
            return rc;
        }

        if ( fumi_block_env.fumicaps & SAHPI_FUMI_CAP_COMPONENTS ) {
            if ( banknum == 0 ) {
                rc = show_logical_bank_component_info( Domain->sessionId,
                                                       fumi_block_env.rptid,
                                                       fumi_block_env.fuminum );
            }
        }
    }

    return rc;
}

ret_code_t fumi_block_backup(void)
{
    return start_backup( Domain->sessionId,
                         fumi_block_env.rptid,
                         fumi_block_env.fuminum );
}

ret_code_t fumi_block_setbootorder(void)
{
    SaHpiBankNumT banknum;
    SaHpiUint32T  position;

    if ( get_banknum( &banknum) != HPI_SHELL_OK ) {
        return HPI_SHELL_PARM_ERROR;
    }
    if ( get_position( &position) != HPI_SHELL_OK ) {
        return HPI_SHELL_PARM_ERROR;
    }

    return set_bank_boot_order( Domain->sessionId,
                                fumi_block_env.rptid,
                                fumi_block_env.fuminum,
                                banknum,
                                position );
}

ret_code_t fumi_block_bankcopy(void)
{
    SaHpiBankNumT srcbanknum;
    SaHpiBankNumT dstbanknum;

    if ( get_banknum_prompt( "Source Bank Num(0 == active bank): ", &srcbanknum) != HPI_SHELL_OK )
    {
        return HPI_SHELL_PARM_ERROR;
    }
    if ( get_banknum_prompt( "Target Bank Num(0 == active bank): ", &dstbanknum) != HPI_SHELL_OK )
    {
        return HPI_SHELL_PARM_ERROR;
    }

    return start_bank_copying( Domain->sessionId,
                               fumi_block_env.rptid,
                               fumi_block_env.fuminum,
                               srcbanknum,
                               dstbanknum );
}

ret_code_t fumi_block_install(void)
{
    SaHpiBankNumT banknum;

    if ( get_banknum( &banknum) != HPI_SHELL_OK ) {
        return HPI_SHELL_PARM_ERROR;
    }

    return start_install( Domain->sessionId,
                          fumi_block_env.rptid,
                          fumi_block_env.fuminum,
                          banknum );
}

ret_code_t fumi_block_status(void)
{
    SaHpiBankNumT banknum;

    if ( get_banknum( &banknum) != HPI_SHELL_OK ) {
        return HPI_SHELL_PARM_ERROR;
    }

    return show_upgrade_status( Domain->sessionId,
                                fumi_block_env.rptid,
                                fumi_block_env.fuminum,
                                banknum );
}

ret_code_t fumi_block_verify(void)
{
    SaHpiBankNumT banknum;

    if ( get_banknum( &banknum) != HPI_SHELL_OK ) {
        return HPI_SHELL_PARM_ERROR;
    }

    return start_target_verification( Domain->sessionId,
                                      fumi_block_env.rptid,
                                      fumi_block_env.fuminum,
                                      banknum );
}

ret_code_t fumi_block_verifymain(void)
{
    return start_main_target_verification( Domain->sessionId,
                                           fumi_block_env.rptid,
                                           fumi_block_env.fuminum );
}

ret_code_t fumi_block_cancel(void)
{
    SaHpiBankNumT banknum;

    if ( get_banknum( &banknum) != HPI_SHELL_OK ) {
        return HPI_SHELL_PARM_ERROR;
    }

    return cancel_upgrade( Domain->sessionId,
                           fumi_block_env.rptid,
                           fumi_block_env.fuminum,
                           banknum );
}

ret_code_t fumi_block_disableautorollback(void)
{
    term_def_t * term;

    term = get_next_term();

    if ( term == NULL ) {
        show_autorollback_disable( Domain->sessionId,
                                   fumi_block_env.rptid,
                                   fumi_block_env.fuminum );
        return HPI_SHELL_OK;
    }
    if ( strcmp(term->term, "on" ) == 0 ) {
        set_autorollback_disable( Domain->sessionId,
                                  fumi_block_env.rptid,
                                  fumi_block_env.fuminum,
                                  SAHPI_TRUE );
    } else if ( strcmp(term->term, "off" ) == 0 ) {
        set_autorollback_disable( Domain->sessionId,
                                  fumi_block_env.rptid,
                                  fumi_block_env.fuminum,
                                  SAHPI_FALSE );
    } else {
        return HPI_SHELL_PARM_ERROR;
    }

    return HPI_SHELL_OK;
}

ret_code_t fumi_block_rollback(void)
{
    return start_rollback( Domain->sessionId,
                           fumi_block_env.rptid,
                           fumi_block_env.fuminum );
}

ret_code_t fumi_block_activate(void)
{
    SaHpiBoolT logical;

    term_def_t * term;

    term = get_next_term();

    if ( term == NULL ) {
        logical = SAHPI_FALSE;
    } else if ( strcmp(term->term, "logical" ) == 0 ) {
        logical = SAHPI_TRUE;
    } else {
        return HPI_SHELL_PARM_ERROR;
    }

    return activate( Domain->sessionId,
                     fumi_block_env.rptid,
                     fumi_block_env.fuminum,
                     logical );
}

ret_code_t fumi_block_cleanup(void)
{
    SaHpiBankNumT banknum;

    if ( get_banknum( &banknum) != HPI_SHELL_OK ) {
        return HPI_SHELL_PARM_ERROR;
    }

    return cleanup( Domain->sessionId,
                    fumi_block_env.rptid,
                    fumi_block_env.fuminum,
                    banknum );
}