Subversion Repositories plb2wbbridge

//////////////////////////////////////////////////////////////////////
////                                                              ////
////  PLB2WB-Bridge                                               ////
////                                                              ////
////  This file is part of the PLB-to-WB-Bridge project           ////
////  http://opencores.org/project,plb2wbbridge                   ////
////                                                              ////
////  Description                                                 ////
////  Implementation of a PLB-to-WB-Bridge according to           ////
////  PLB-to-WB Bridge specification document.                    ////
////                                                              ////
////  To Do:                                                      ////
////   Nothing                                                    ////
////                                                              ////
////  Author(s):                                                  ////
////      - Christian Haettich                                    ////
////        feddischson@opencores.org                             ////
////                                                              ////
//////////////////////////////////////////////////////////////////////
////                                                              ////
//// Copyright (C) 2010 Authors                                   ////
////                                                              ////
//// This source file may be used and distributed without         ////
//// restriction provided that this copyright statement is not    ////
//// removed from the file and that any derivative work contains  ////
//// the original copyright notice and the associated disclaimer. ////
////                                                              ////
//// This source file is free software; you can redistribute it   ////
//// and/or modify it under the terms of the GNU Lesser General   ////
//// Public License as published by the Free Software Foundation; ////
//// either version 2.1 of the License, or (at your option) any   ////
//// later version.                                               ////
////                                                              ////
//// This source 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.  See the GNU Lesser General Public License for more ////
//// details.                                                     ////
////                                                              ////
//// You should have received a copy of the GNU Lesser General    ////
//// Public License along with this source; if not, download it   ////
//// from http://www.opencores.org/lgpl.shtml                     ////
////                                                              ////
//////////////////////////////////////////////////////////////////////
 
#include "plb2wb_bridge.h"
#include "xstatus.h"
#include "xparameters.h"
#include "xio.h"
 
 
 
static void WBResetStubHandler( void *CallBackRef )
{
   XASSERT_VOID( FALSE );
}
 
 
static void StubHandler( void *CallBackRef )
{
 
	XASSERT_VOID(CallBackRef != NULL);
 
	( (PLB2WB_Bridge *) CallBackRef )->UnhandledInterrupts++;
}
 
 
 
//
//  Note,  this handlers MUST be implemented.
//  If no handler is implemented and interrupt is rised,
//  this stubs never return!!
//
//
static void StubWBRstHandler( void *CallBackRef )
{
	XASSERT_VOID( FALSE );
 
}
 
static void StubWBWrHandler( void *CallBackRef )
{
	XASSERT_VOID( FALSE );
}
 
 
void PLB2WB_Bridge_DeviceInterruptHandler( void* ptr )
{
 
   u32 status_reg;
   u32 irq_reg;
   u32 addr_reg;
   u32 datum_reg;
   u8  i;
   PLB2WB_Bridge_VectorTableEntry *entry;
 
   PLB2WB_Bridge* InstancePtr = (PLB2WB_Bridge*) ptr;
 
 
   status_reg = XIo_In32( InstancePtr->StatusBaseAddress + PLB2WB_STATUS );
 
 
 
   // call write-error handler
   if ( status_reg & PLB2WB_STATUS_WERR )
   {
      entry = &InstancePtr->WBWrErrorHandler;
      entry->Handler( entry->CallBackRef );
   }
 
 
   // call irq-handler
   if ( status_reg & PLB2WB_STATUS_WBIRQ )
   {
      irq_reg = XIo_In32( InstancePtr->StatusBaseAddress + PLB2WB_STATUS_IRQ  );
      for( i=0; i<32; i++ )
      {
         if( irq_reg & ( 1 << ( 31 - i ) ) )
         {
            entry = &InstancePtr->HandlerTable[i];
            entry->Handler( entry->CallBackRef );
         }
      }
   }
 
 
   // call reset handler
   if ( status_reg & PLB2WB_STATUS_WBRST )
   {
      entry = &InstancePtr->WBRstHandler;
      entry->Handler( entry->CallBackRef );
   }
 
   // clear bridge-irq
   XIo_Out32( InstancePtr->StatusBaseAddress + PLB2WB_STATUS, 0 );
 
   // clear mb-irq
   XIntc_Acknowledge( InstancePtr->xintcInstancePtr, InstancePtr->irqID );
}
 
 
 
 
 
PLB2WB_Bridge_Config *PLB2WB_Bridge_LookupConfig( u16 DeviceId )
{
	PLB2WB_Bridge_Config *CfgPtr = NULL;
 
	int i;
	for ( i = 0; i < XPAR_PLB2WB_BRIDGE_NUM_INSTANCES; i++ ) 
   {
		if ( PLB2WB_Bridge_ConfigTable[i].DeviceId == DeviceId ) 
      {
			CfgPtr = &PLB2WB_Bridge_ConfigTable[i];
			break;
		}
	}
 
	return CfgPtr;
}
 
 
 
int PLB2WB_Bridge_Initialize( PLB2WB_Bridge * InstancePtr, u16 DeviceId, XIntc* xintcInstancePtr, u8 irqID )
{
   u8 i;
 
   PLB2WB_Bridge_Config *ConfigPtr;
 
   XASSERT_NONVOID( InstancePtr != NULL );
 
   ConfigPtr = PLB2WB_Bridge_LookupConfig( DeviceId );
 
   if ( ConfigPtr == ( PLB2WB_Bridge_Config * ) NULL ) 
   {
   	InstancePtr->IsReady = 0;
   	return ( XST_DEVICE_NOT_FOUND );
   }
 
 
   InstancePtr->StatusBaseAddress   = ConfigPtr->StatusBaseAddress;
   InstancePtr->BaseAddress         = ConfigPtr->BaseAddress;
   InstancePtr->CfgPtr              = ConfigPtr;
 
   for( i=0; i < XPAR_PLB2WB_BRIDGE_0_WB_PIC_INTS; i++ )
   {
      InstancePtr->HandlerTable[i].Handler = StubHandler;
		InstancePtr->HandlerTable[i].CallBackRef = InstancePtr;
   }
 
   InstancePtr->WBWrErrorHandler.Handler = StubWBWrHandler;
   InstancePtr->WBWrErrorHandler.CallBackRef = StubWBWrHandler;
 
   InstancePtr->WBRstHandler.Handler = StubWBRstHandler;
   InstancePtr->WBRstHandler.CallBackRef = InstancePtr;
 
 
 
   InstancePtr->xintcInstancePtr = xintcInstancePtr;
   InstancePtr->irqID            = irqID;
	InstancePtr->IsReady          = XCOMPONENT_IS_READY;
 
   return XST_SUCCESS;
}
 
 
 
int PLB2WB_Bridge_Connect_WBRstHandler( PLB2WB_Bridge* InstancePtr, 
                                        XInterruptHandler Handler, void* CallBackRef )
{
   XASSERT_NONVOID( InstancePtr != NULL );
   XASSERT_NONVOID( Handler != NULL );
   XASSERT_NONVOID( InstancePtr->IsReady == XCOMPONENT_IS_READY );
 
   InstancePtr->WBRstHandler.Handler = Handler;
   InstancePtr->WBRstHandler.CallBackRef = CallBackRef;
 
   return XST_SUCCESS;
}
 
int PLB2WB_Bridge_Connect_WBWrErrHandler( PLB2WB_Bridge* InstancePtr, XInterruptHandler Handler, void* CallBackRef )
{
   XASSERT_NONVOID( InstancePtr != NULL );
   XASSERT_NONVOID( Handler != NULL );
   XASSERT_NONVOID( InstancePtr->IsReady == XCOMPONENT_IS_READY );
 
   InstancePtr->WBWrErrorHandler.Handler = Handler;
   InstancePtr->WBWrErrorHandler.CallBackRef = CallBackRef;
 
   return XST_SUCCESS;
}
 
 
int PLB2WB_Bridge_Connect( PLB2WB_Bridge* InstancePtr, u8 Id, 
                           XInterruptHandler Handler, void* CallBackRef )
{
   XASSERT_NONVOID( InstancePtr != NULL );
   XASSERT_NONVOID( Id < XPAR_PLB2WB_BRIDGE_0_WB_PIC_INTS );
   XASSERT_NONVOID( Handler != NULL );
   XASSERT_NONVOID( InstancePtr->IsReady == XCOMPONENT_IS_READY );
 
   InstancePtr->HandlerTable[Id].Handler = Handler;
   InstancePtr->HandlerTable[Id].CallBackRef = CallBackRef;
 
   return XST_SUCCESS;
}
 
 
 
void PLB2WB_Bridge_Disconnect( PLB2WB_Bridge * InstancePtr, u8 Id )
{
   u32 CurrentIER;
   u32 Mask;
 
   XASSERT_VOID(InstancePtr != NULL);
   XASSERT_VOID(Id < XPAR_PLB2WB_BRIDGE_0_WB_PIC_INTS );
   XASSERT_VOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);
 
   InstancePtr->HandlerTable[Id].Handler = StubHandler;
   InstancePtr->HandlerTable[Id].CallBackRef = InstancePtr;
}
 
 
 
void  PLB2WB_Bridge_WBContinue            ( PLB2WB_Bridge* InstancePtr )
{
   XASSERT_VOID(InstancePtr != NULL);
 
   XIo_Out32( InstancePtr->StatusBaseAddress + PLB2WB_STATUS_CON, 0 );
}
 
 
 
void  PLB2WB_Bridge_WBAbort               ( PLB2WB_Bridge* InstancePtr )
{
   XASSERT_VOID(InstancePtr != NULL);
 
   XIo_Out32( InstancePtr->StatusBaseAddress + PLB2WB_STATUS_ABO, 0 );
}
 
 
void  PLB2WB_Bridge_SoftReset             ( PLB2WB_Bridge* InstancePtr )
{
   XASSERT_VOID(InstancePtr != NULL);
 
   XIo_Out32( InstancePtr->StatusBaseAddress + PLB2WB_STATUS_RST, 0 );
}