Logo Search packages:      
Sourcecode: raidutils version File versions  Download package

engiface.cpp

/* Copyright (c) 1996-2004, Adaptec Corporation
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * - Redistributions of source code must retain the above copyright notice, this
 *   list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 * - Neither the name of the Adaptec Corporation nor the names of its
 *   contributors may be used to endorse or promote products derived from this
 *   software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

//File - ENGIFACE.CPP
//***************************************************************************
//
//Description:
//
//    This file contains the function definitions for the DPT
//engine interface class.  The engine interface class is designed
//to facilitate access to the DPT engine.
//
//Author:   Doug Anderson
//Date:           7/18/94
//
//***************************************************************************


//Include Files -------------------------------------------------------------
#include <stdio.h>

#include "engiface.hpp"
#include "id_list.hpp"
#include "dpt_api.h"

extern "C" uLONG engineTimeOut = 0;

//Function - DPT_EngineIO_C::DPT_EngineIO_C() - start
//===========================================================================
//
//Description:
//
//    This function is the constructor for the engine I/O structure.
//
//---------------------------------------------------------------------------

DPT_EngineIO_C::DPT_EngineIO_C(
            uLONG fromEngSize,
            uLONG toEngSize
            )
{

toEng_P           = NULL;
fromEng_P   = NULL;
AllocFromEng(fromEngSize);
AllocIObuff(&toEng_P,toEngSize);

connectTag  = 0;
compatability     = 0;

EngineProc = 0;
SetDataPointers();

}
//DPT_EngineIO_C::DPT_EngineIO_C() - end


//Function - DPT_EngineIO_C::operator= - start
//===========================================================================
//
//Description:
//
//    This function is an overload for operator= that handles const references--MSS
//
//---------------------------------------------------------------------------
DPT_EngineIO_C& DPT_EngineIO_C::operator=(const DPT_EngineIO_C& inEngine)
{
      if(this == &inEngine)
            return *this;

      // copy member vars here
      maxIDs        = inEngine.maxIDs;
      connectTag    = inEngine.connectTag;
      compatability = inEngine.compatability;
      ids           = inEngine.ids;
      loggerIDs     = inEngine.loggerIDs;

      AllocIObuff(&toEng_P, inEngine.toEng_P->allocSize);
      memcpy(toEng_P->data, inEngine.toEng_P->data, inEngine.toEng_P->allocSize);

      AllocFromEng(inEngine.fromEng_P->allocSize);
      memcpy(fromEng_P->data, inEngine.fromEng_P->data, inEngine.fromEng_P->allocSize);
      SetDataPointers();

      return *this;
}
//DPT_EngineIO_C::operator= - end


//Function - DPT_EngineIO_C::AllocFromEng() - start
//===========================================================================
//
//Description:
//
//    This function allocates or reallocates the "from engine"
//I/O buffer.
//
//---------------------------------------------------------------------------

DPT_RTN_T   DPT_EngineIO_C::AllocFromEng(uLONG allocSize)
{

//-----------------------------------
// Attempt to allocate the new buffer
//-----------------------------------

DPT_RTN_T rtnVal = AllocIObuff(&fromEng_P,allocSize);
SetDataPointers();


return (rtnVal);

}
//DPT_EngineIO_C::AllocFromEng() - end

// Function - void DPT_EngineIO_C::SetDataPointers() - start
//===========================================================================
//
//Description:  
//
//
//
//Parameters:  
//
//Return Value:  
//
//Global Variables Affected:  
//
//Remarks: (Side effects, Assumptions, Warnings...) 
//
//
//===========================================================================
void DPT_EngineIO_C::SetDataPointers()
{
      //--------------------------------------------
      // Set up the "from engine" structure pointers
      //--------------------------------------------

      if (fromEng_P != NULL) {
            hbaInfo_P   = (dptHBAinfo_S *)      fromEng_P->data;
            devInfo_P   = (dptDevInfo_S *)      fromEng_P->data;
            progInfo_P  = (dptProgress_S *)     fromEng_P->data;
            sysInfo_P   = (sysInfo_S *)         fromEng_P->data;
      }
      else {
            hbaInfo_P   = NULL;
            devInfo_P   = NULL;
            progInfo_P  = NULL;
            sysInfo_P   = NULL;
      }
}
// end - void DPT_EngineIO_C::SetDataPointers()

//Function - DPT_EngineIO_C::AllocIObuff() - start
//===========================================================================
//
//Description:
//
//    This function allocates an engine I/O buffer.
//
//---------------------------------------------------------------------------

DPT_RTN_T   DPT_EngineIO_C::AllocIObuff(dptBuffer_S **buff_P,uLONG allocSize)
{

uLONG       oldSize;
uLONG           TotalAllocSize;
DPT_RTN_T   rtnVal = MSG_RTN_COMPLETED;

  // If the buffer is to be allocated...
if (allocSize) {
      rtnVal = MSG_RTN_FAILED;
        // If there is an existing buffer...
      if (*buff_P!=NULL) {
            oldSize = (*buff_P)->allocSize;
            dptBuffer_S::delBuffer(*buff_P);
      }
      else
            oldSize = 0;

       //
       // Set up the alloc size to include the buffer header
       //
       TotalAllocSize = sizeof(dptBuffer_S)-1 + allocSize;
    
       //
       // Now lets make sure the size is an even multiple of 16, and
       // just for good measure we will buffer it by 16 for all of those
       // environments that have a problem with alignment
       //
       TotalAllocSize = (TotalAllocSize & 0xfffffff0) + 0x10;
    
        // Try to allocate the new buffer size
      if ((*buff_P = (dptBuffer_S *) new uCHAR[TotalAllocSize]) != NULL) {
            (*buff_P)->allocSize = allocSize;
            rtnVal = MSG_RTN_COMPLETED;
      }

        // If unable to allocate the new buffer size...
      if ((*buff_P == NULL) && oldSize)
      // Try to allocate the old buffer size
            *buff_P = dptBuffer_S::newBuffer(oldSize);
}

return (rtnVal);

}
//DPT_EngineIO_C::AllocIObuff() - end


//Function - DPT_EngineIO_C::Connect() - start
//===========================================================================
//
//Description:
//
//    This function attempts to establish a connection with the
//DPT engine.  If the specified compatability word does not match
//the engine's compatability, this function will disconnect from
//the engine.  If the specified compatability word is zero, no
//compatability check is performed.
//
//---------------------------------------------------------------------------

DPT_RTN_T   DPT_EngineIO_C::Connect(uLONG inCompatability, uSHORT ioMethod, DPT_TAG_T target,
            uCHAR extractConnTag)
{

DPT_RTN_T   rtnVal;

Reset();
  // Request SmartRom as the I/O method
Insert(ioMethod);
  // Make a connection
if ((rtnVal = Send(MSG_CONNECT, target)) == MSG_RTN_COMPLETED) {
        // Get the engine's compatability word
      Extract(compatability);

      if (extractConnTag)
            // Get the connection key
            Extract(connectTag);

        // If the compatability word is to be used and does not match...
      if (inCompatability && (inCompatability != compatability)) {
            rtnVal = MSG_RTN_FAILED;
            Disconnect();
            connectTag = 0;
      }
}
Reset();

return (rtnVal);

}
//DPT_EngineIO_C::Connect() - end


//Function - DPT_EngineIO_C::GetIDs() - start
//===========================================================================
//
//Description:
//
//    This function sends the specified object ID message to the
//DPT engine and places the returned IDs into the id_P buffer.
//
//---------------------------------------------------------------------------

DPT_RTN_T   DPT_EngineIO_C::GetIDs(DPT_MSG_T message,DPT_TAG_T targetTag)
{

DPT_RTN_T   rtnVal;

  // Send the engine object ID message
      if (!((rtnVal=Send(message,targetTag)) & MSG_RTN_FAILED))
            rtnVal = ids.CopyBuffer(fromEng_P);

return (rtnVal);

}
//DPT_EngineIO_C::GetIDs() - end

//Function - DPT_EngineIO_C::GetLoggerIDs() - start
//===========================================================================
//
//Description:
//
//    This function sends the specified object ID message to the
//DPT engine and places the returned IDs into the id_P buffer.
//
//---------------------------------------------------------------------------

DPT_RTN_T   DPT_EngineIO_C::GetLoggerIDs(DPT_MSG_T message,DPT_TAG_T targetTag)
{

DPT_RTN_T   rtnVal;

  // Send the engine object ID message
      if (!((rtnVal=Send(message,targetTag)) & MSG_RTN_FAILED))
            rtnVal = loggerIDs.CopyBuffer(fromEng_P);

return (rtnVal);

}
//DPT_EngineIO_C::GetLoggerIDs() - end



//Function - DPT_EngineIO_C::Send() - start
//===========================================================================
//
//Description:
//    This function send the specified message to the DPT engine.
//
//---------------------------------------------------------------------------

DPT_RTN_T   DPT_EngineIO_C::Send(DPT_MSG_T message,DPT_TAG_T targetTag)
{

#ifdef _USE_RT_ENG_LINKING
            if( EngineProc )
            {
                  return ( (EngineProc)(
                                                connectTag,
                                                message,
                                                targetTag,
                                                fromEng_P,
                                                toEng_P,
                                                engineTimeOut) );
            }
            else
                  return MSG_RTN_FAILED;
#else
            return (DPT_CallEngine(connectTag,message,targetTag,fromEng_P,toEng_P,engineTimeOut));
#endif

}
//DPT_EngineIO_C::Send() - end


//Function - DPT_EngineIO_C::Send() - start
//===========================================================================
//
//Description:
//    This function send the specified message to the DPT engine.
//
//---------------------------------------------------------------------------

DPT_RTN_T   DPT_EngineIO_C::Send(DPT_MSG_T message,
                             DPT_TAG_T targetTag,
                             dptBuffer_S *inFromEng_P,
                             dptBuffer_S *inToEng_P
                            )
{

#ifdef _USE_RT_ENG_LINKING
            if( EngineProc )
            {
                  return ( (EngineProc)(
                                                connectTag,
                                                message,
                                                targetTag,
                                                inFromEng_P,
                                                inToEng_P,
                                                engineTimeOut) );
            }
            else
                  return MSG_RTN_FAILED;
#else
            return (DPT_CallEngine(connectTag,message,targetTag,inFromEng_P,inToEng_P,engineTimeOut));
#endif

}
//Send() - end


//Function - DPT_EngineIO_C::~DPT_EngineIO_C() - start
//===========================================================================
//
//Description:
//
//    This function is the destructor for the engine I/O structure.
//
//---------------------------------------------------------------------------

DPT_EngineIO_C::~DPT_EngineIO_C()
{
      delete toEng_P;
   delete fromEng_P;
}
//DPT_EngineIO_C::~DPT_EngineIO_C() - end




Generated by  Doxygen 1.6.0   Back to index