786 lines
27 KiB
C
786 lines
27 KiB
C
/*******************************************************************************
|
|
*Copyright (c) 2014 PMC-Sierra, Inc. All rights reserved.
|
|
*
|
|
*Redistribution and use in source and binary forms, with or without modification, are permitted provided
|
|
*that the following conditions are met:
|
|
*1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
|
|
*following disclaimer.
|
|
*2. 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.
|
|
*
|
|
*THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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
|
|
|
|
*******************************************************************************/
|
|
|
|
|
|
MALLOC_DEFINE( M_PMC_OSTI, "osti_cacheable", "allocated from ostiAllocMemory as cacheable memory" );
|
|
|
|
|
|
/******************************************************************************
|
|
ostiAllocMemory()
|
|
Purpose:
|
|
TD layer calls to get dma memory
|
|
Parameters:
|
|
tiRoot_t *ptiRoot (IN) Pointer refers to the current root
|
|
void **osMemHandle (IN_OUT) Pointer To OS Mem handle to fill in
|
|
void **agVirtAddr (IN_OUT) Pointer to allocated memory address
|
|
U32 *agPhysUpper32 (IN_OUT) Pointer to Up 32 bit mem phys addr.
|
|
U32 *agPhysLower32 (IN_OUT) Pointer to low 32 bit mem phys addr.
|
|
U32 alignment (IN) Alignment requirement
|
|
U32 allocLength (IN) Required memory length
|
|
agBOOLEAN isChacheable (IN) Required memory type
|
|
Return:
|
|
tiSuccess - success
|
|
tiMemoryTooLarge - requested memory size too large
|
|
tiMemoryNotAvail - no dma memory available
|
|
Note:
|
|
for sata use.
|
|
where a cacheable allocation inherently may be swapped, the values
|
|
agPhysUpper32 and agPhysLower32 are understood to mean nothing when the
|
|
value isCacheable is set to true. these phys values must not be used by
|
|
the caller.
|
|
******************************************************************************/
|
|
osGLOBAL U32 ostiAllocMemory( tiRoot_t *ptiRoot,
|
|
void **osMemHandle,
|
|
void **agVirtAddr,
|
|
U32 *agPhysUpper32,
|
|
U32 *agPhysLower32,
|
|
U32 alignment,
|
|
U32 allocLength,
|
|
agBOOLEAN isCacheable )
|
|
{
|
|
ag_card_info_t *pCardInfo = TIROOT_TO_CARDINFO( ptiRoot );
|
|
ag_dma_addr_t *pMem;
|
|
struct agtiapi_softc *pCard;
|
|
pCard = TIROOT_TO_CARD(ptiRoot);
|
|
|
|
AGTIAPI_PRINTK( "ostiAllocMemory: debug, cache? %d size %d alloc algn %d ### \n",
|
|
isCacheable, allocLength, alignment );
|
|
|
|
if( pCardInfo->topOfFreeDynamicMem == 0 ) {
|
|
AGTIAPI_PRINTK( "ostiAllocMemory: No space left, increase "
|
|
"AGTIAPI_DYNAMIC_MAX! ERROR\n" );
|
|
return tiMemoryNotAvail;
|
|
}
|
|
|
|
pMem = pCardInfo->freeDynamicMem[pCardInfo->topOfFreeDynamicMem - 1];
|
|
|
|
// where this memory has bee preallocated, be sure requirements do not
|
|
// exceed the limits of resources available
|
|
if( allocLength > 4096 ) {
|
|
AGTIAPI_PRINTK( "ostiAllocMemory: no-cache size 0x%x alloc NOT AVAILABLE\n",
|
|
allocLength );
|
|
return tiMemoryNotAvail;
|
|
}
|
|
if( alignment > 32 ) {
|
|
AGTIAPI_PRINTK( "ostiAllocMemory: no-cache alignment 0x%x NOT AVAILABLE\n",
|
|
alignment );
|
|
return tiMemoryNotAvail;
|
|
}
|
|
|
|
pMem->dmaPhysAddr = pMem->nocache_busaddr;
|
|
pMem->dmaVirtAddr = pMem->nocache_mem;
|
|
pMem->memSize = allocLength;
|
|
*agVirtAddr = pMem->dmaVirtAddr;
|
|
|
|
*agPhysUpper32 = HIGH_32_BITS( pMem->dmaPhysAddr );
|
|
*agPhysLower32 = LOW_32_BITS( pMem->dmaPhysAddr );
|
|
|
|
mtx_lock(&pCard->memLock);
|
|
pCardInfo->topOfFreeDynamicMem--;
|
|
*osMemHandle = (void *)pMem; // virtAddr;
|
|
mtx_unlock(&pCard->memLock);
|
|
|
|
return tiSuccess;
|
|
}
|
|
|
|
/******************************************************************************
|
|
ostiIOCTLWaitForSignal()
|
|
Purpose:
|
|
Function to wait semaphore during ioctl
|
|
Parameters:
|
|
tiRoot_t *ptiRoot (IN) Pointer to the current HBA
|
|
void **agParam1 (IN_OUT) Pointer to context to be passed
|
|
void **agParam2 (IN_OUT) Pointer to context to be passed
|
|
void **agParam (IN_OUT) Pointer to context to be passed
|
|
Return:
|
|
Note:
|
|
******************************************************************************/
|
|
osGLOBAL void
|
|
ostiIOCTLWaitForSignal(tiRoot_t *ptiRoot,
|
|
void *agParam1,
|
|
void *agParam2,
|
|
void *agParam3)
|
|
{
|
|
struct agtiapi_softc *pCard;
|
|
pCard = TIROOT_TO_CARD(ptiRoot);
|
|
|
|
pCard->down_count++;
|
|
sema_wait (pCard->pIoctlSem);
|
|
}
|
|
|
|
/* Below function has to be changed to use wait for completion */
|
|
osGLOBAL void
|
|
ostiIOCTLWaitForComplete(tiRoot_t *ptiRoot,
|
|
void *agParam1,
|
|
void *agParam2,
|
|
void *agParam3)
|
|
{
|
|
struct agtiapi_softc *pCard;
|
|
pCard = TIROOT_TO_CARD(ptiRoot);
|
|
|
|
pCard->down_count++;
|
|
sema_wait (pCard->pIoctlSem);
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
ostiChipConfigReadBit32()
|
|
Purpose:
|
|
Read 32-bit value from PCI configuration register
|
|
Parameters:
|
|
tiRoot_t *ptiRoot (IN) Pointer to tiRoot structure
|
|
U32 chipConfigOffset (IN) Offset to PCI configuration register
|
|
Return:
|
|
32 bit data
|
|
******************************************************************************/
|
|
U32 ostiChipConfigReadBit32( tiRoot_t *ptiRoot, U32 chipConfigOffset )
|
|
{
|
|
device_t lDev = TIROOT_TO_PCIDEV(ptiRoot);
|
|
u_int32_t lData = 0;
|
|
|
|
lData = pci_read_config( lDev, chipConfigOffset, 4 );
|
|
|
|
return (U32)lData;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
ostiChipConfigWriteBit32()
|
|
Purpose:
|
|
Write 32-bit value to PCI configuration register
|
|
Parameters:
|
|
tiRoot_t *ptiRoot (IN) Pointer to tiRoot structure
|
|
U32 chipConfigOffset (IN) Offset to PCI configuration register
|
|
U32 chipConfigValue (IN) Value to be written
|
|
Return: none
|
|
******************************************************************************/
|
|
void ostiChipConfigWriteBit32( tiRoot_t *ptiRoot,
|
|
U32 chipConfigOffset,
|
|
U32 chipConfigValue )
|
|
{
|
|
device_t lDev = TIROOT_TO_PCIDEV(ptiRoot);
|
|
pci_write_config( lDev, chipConfigOffset, chipConfigValue, 4 );
|
|
}
|
|
|
|
/******************************************************************************
|
|
ostiChipReadBit32()
|
|
Purpose:
|
|
Read 32-bit value from PCI address register
|
|
Parameters:
|
|
tiRoot_t *ptiRoot (IN) Pointer to tiRoot structure
|
|
U32 chipOffset (IN) Offset to PCI configuration register
|
|
Return:
|
|
32 bit data
|
|
******************************************************************************/
|
|
U32 ostiChipReadBit32(tiRoot_t *ptiRoot, U32 chipOffset)
|
|
{
|
|
U32 data;
|
|
ag_card_info_t *pCardInfo;
|
|
|
|
pCardInfo = TIROOT_TO_CARDINFO(ptiRoot);
|
|
data = *(U32 *)(pCardInfo->pciMemVirtAddr + chipOffset);
|
|
return data;
|
|
}
|
|
|
|
/******************************************************************************
|
|
ostiChipWriteBit32()
|
|
Purpose:
|
|
Write 32-bit value to PCI address register
|
|
Parameters:
|
|
tiRoot_t *ptiRoot (IN) Pointer to tiRoot structure
|
|
U32 chipOffset (IN) Offset to PCI configuration register
|
|
U32 chipValue (IN) Value to be written
|
|
Return: none
|
|
******************************************************************************/
|
|
void ostiChipWriteBit32( tiRoot_t *ptiRoot, U32 chipOffset, U32 chipValue )
|
|
{
|
|
ag_card_info_t *pCardInfo;
|
|
pCardInfo = TIROOT_TO_CARDINFO(ptiRoot);
|
|
*(U32 *)(pCardInfo->pciMemVirtAddr + chipOffset) = chipValue;
|
|
}
|
|
|
|
/******************************************************************************
|
|
ostiChipReadBit32Ext()
|
|
Purpose:
|
|
Read 32-bit value from PCI address register
|
|
Parameters:
|
|
tiRoot_t *ptiRoot (IN) Pointer to tiRoot structure
|
|
busBaseNumber PCI BAR number
|
|
U32 chipOffset (IN) Offset to PCI configuration register
|
|
Return:
|
|
32 bit data
|
|
******************************************************************************/
|
|
U32 ostiChipReadBit32Ext( tiRoot_t *ptiRoot,
|
|
U32 busBaseNumber,
|
|
U32 chipOffset )
|
|
{
|
|
U32 data;
|
|
ag_card_info_t *pCardInfo;
|
|
|
|
pCardInfo = TIROOT_TO_CARDINFO(ptiRoot);
|
|
data = *(U32 *)((pCardInfo->pciMemVirtAddrSpc[busBaseNumber]) + chipOffset );
|
|
return data;
|
|
}
|
|
|
|
/******************************************************************************
|
|
ostiChipWriteBit32Ext()
|
|
Purpose:
|
|
Write 32-bit value to PCI address register
|
|
Parameters:
|
|
tiRoot_t *ptiRoot (IN) Pointer to tiRoot structure
|
|
busBaseNumber PCI BAR number
|
|
U32 chipOffset (IN) Offset to PCI configuration register
|
|
U32 chipValue (IN) Value to be written
|
|
Return: none
|
|
******************************************************************************/
|
|
void ostiChipWriteBit32Ext( tiRoot_t *ptiRoot,
|
|
U32 busBaseNumber,
|
|
U32 chipOffset,
|
|
U32 aData )
|
|
{
|
|
ag_card_info_t *pCardInfo;
|
|
pCardInfo = TIROOT_TO_CARDINFO(ptiRoot);
|
|
*(U32 *)((pCardInfo->pciMemVirtAddrSpc[busBaseNumber]) + chipOffset ) = aData;
|
|
}
|
|
|
|
/******************************************************************************
|
|
ostiChipReadBit8()
|
|
Purpose:
|
|
Read 8-bit value from PCI address register
|
|
Parameters:
|
|
tiRoot_t *ptiRoot (IN) Pointer to tiRoot structure
|
|
U32 chipOffset (IN) Offset to PCI configuration register
|
|
Return:
|
|
8 bit data
|
|
******************************************************************************/
|
|
U08 ostiChipReadBit8( tiRoot_t *ptiRoot, U32 chipOffset )
|
|
{
|
|
ag_card_info_t *pCardInfo;
|
|
pCardInfo = TIROOT_TO_CARDINFO(ptiRoot);
|
|
return *(U08 *)( pCardInfo->pciMemVirtAddr + chipOffset );
|
|
}
|
|
|
|
/******************************************************************************
|
|
ostiChipWriteBit8()
|
|
Purpose:
|
|
Write 8-bit value to PCI address register
|
|
Parameters:
|
|
tiRoot_t *ptiRoot (IN) Pointer to tiRoot structure
|
|
U32 chipOffset (IN) Offset to PCI configuration register
|
|
U8 chipValue (IN) Value to be written
|
|
Return: none
|
|
******************************************************************************/
|
|
void ostiChipWriteBit8( tiRoot_t *ptiRoot, U32 chipOffset, U08 chipValue )
|
|
{
|
|
ag_card_info_t *pCardInfo;
|
|
pCardInfo = TIROOT_TO_CARDINFO(ptiRoot);
|
|
*(U08 *)( pCardInfo->pciMemVirtAddr + chipOffset ) = chipValue;
|
|
}
|
|
|
|
|
|
void ostiFlashReadBlock(tiRoot_t *ptiRoot,
|
|
U32 offset,
|
|
void *bufPtr,
|
|
U32 nbytes)
|
|
{
|
|
AGTIAPI_PRINTK( "ostiFlashReadBlock: No support for iscsi device\n" );
|
|
}
|
|
|
|
/******************************************************************************
|
|
ostiFreeMemory()
|
|
Purpose:
|
|
TD layer calls to free allocated dma memory
|
|
Parameters:
|
|
tiRoot_t *ptiRoot (IN) Pointer refers to the current root
|
|
void *osMemHandle (IN) Pointer to OS mem handle to be released
|
|
u32 allocLength (IN) Aloocated memory length in byte
|
|
Return:
|
|
tiSuccess - success
|
|
tiInvalidHandle - handle is invalid
|
|
******************************************************************************/
|
|
osGLOBAL U32 ostiFreeMemory( tiRoot_t *ptiRoot,
|
|
void *osMemHandle,
|
|
U32 allocLength )
|
|
{
|
|
ag_card_info_t *pCardInfo = TIROOT_TO_CARDINFO( ptiRoot );
|
|
ag_dma_addr_t *pMem = (ag_dma_addr_t*)osMemHandle;
|
|
struct agtiapi_softc *pCard;
|
|
pCard = TIROOT_TO_CARD(ptiRoot);
|
|
|
|
if( !osMemHandle ) {
|
|
AGTIAPI_PRINTK( "ostiFreeMemory: NULL handle ERROR\n" );
|
|
return tiInvalidHandle;
|
|
}
|
|
|
|
AGTIAPI_PRINTK( "ostiFreeMemory: debug messsage %p ### \n",
|
|
(void*)pMem->dmaPhysAddr );
|
|
|
|
// mark as unused
|
|
pMem->memSize = 0;
|
|
pMem->dmaVirtAddr = NULL;
|
|
pMem->dmaPhysAddr = 0;
|
|
|
|
if (pCardInfo->topOfFreeDynamicMem == AGTIAPI_DYNAMIC_MAX) {
|
|
AGTIAPI_PRINTK( "ostiFreeMemory: too many free slots ERROR\n" );
|
|
return tiInvalidHandle;
|
|
}
|
|
|
|
mtx_lock(&pCard->memLock);
|
|
pCardInfo->freeDynamicMem[pCardInfo->topOfFreeDynamicMem++] = pMem;
|
|
mtx_unlock(&pCard->memLock);
|
|
|
|
return tiSuccess;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
ostiMakeParamString()
|
|
Purpose:
|
|
Utility function to simplify flow in ostiGetTransportParam(). Produces
|
|
a string handle constructed from ostiGetTransportParam() values:
|
|
key, subkey1, subkey2, subkey3, subkey4, subkey5, and valueName.
|
|
Parameters:
|
|
S08 *aKey (IN) Pointer to 1st level parameter string
|
|
S08 *aSubkey1 (IN) Pointer to 2nd level parameter string
|
|
S08 *aSubkey2 (IN) Pointer to 3rd level parameter string
|
|
S08 *aSubkey3 (IN) Pointer to 4th level parameter string
|
|
S08 *aSubkey4 (IN) Pointer to 5th level parameter string
|
|
S08 *aSubkey5 (IN) Pointer to 6th level parameter string
|
|
S08 *aValueName (IN) Pointer to name string of the value under keys
|
|
S08 *aFullKey (OUT) Pointer to returned key-value-handle buffer
|
|
U32 *apLenFullKey (OUT) String length in the key-value-handle buffer
|
|
Return:
|
|
tiSuccess - Success
|
|
tiError - Failed
|
|
Note:
|
|
If all input strings are NULL, tiError will return with zero in apLenFullKey
|
|
*****************************************************************************/
|
|
inline static U32 ostiMakeParamString( S08 *aKey,
|
|
S08 *aSubkey1,
|
|
S08 *aSubkey2,
|
|
S08 *aSubkey3,
|
|
S08 *aSubkey4,
|
|
S08 *aSubkey5,
|
|
S08 *aValueName,
|
|
S08 *aFullKey,
|
|
U32 *apLenFullKey )
|
|
{
|
|
// preliminary sanity checks
|
|
if( agNULL == aKey ) {
|
|
*apLenFullKey = 0;
|
|
printf( "ostiGetTransportParam called with no key. how odd.\n" );
|
|
return tiError;
|
|
}
|
|
if( agNULL == aValueName ) {
|
|
*apLenFullKey = 0;
|
|
printf( "ostiGetTransportParam called with no value-name. how odd.\n" );
|
|
return tiError;
|
|
}
|
|
|
|
strcpy( aFullKey, "DPMC_" ); // start at the beginning of the string
|
|
strcat( aFullKey, aKey );
|
|
|
|
int lIdx;
|
|
S08 *lStrIdx = agNULL;
|
|
for( lIdx = 1; lIdx <= 5; lIdx++ ) {
|
|
if( 1 == lIdx) lStrIdx = aSubkey1;
|
|
if( 2 == lIdx) lStrIdx = aSubkey2;
|
|
if( 3 == lIdx) lStrIdx = aSubkey3;
|
|
if( 4 == lIdx) lStrIdx = aSubkey4;
|
|
if( 5 == lIdx) lStrIdx = aSubkey5;
|
|
if( agNULL == lStrIdx ) break; // no more key information
|
|
// append key information
|
|
strcat( aFullKey, "_" );
|
|
strcat( aFullKey, lStrIdx );
|
|
}
|
|
|
|
// only the value name is left to append
|
|
strcat( aFullKey, "_" );
|
|
strcat( aFullKey, aValueName );
|
|
|
|
*apLenFullKey = strlen( aFullKey ); // 58 is max len seen; June 11, 2012
|
|
// printf( "ostiMakeParamString: x%d out-str:%s\n", // debug print
|
|
// *apLenFullKey, aFullKey );
|
|
|
|
return tiSuccess; // ship it chief
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
ostiGetTransportParam()
|
|
Purpose:
|
|
Call back function from lower layer to get parameters.
|
|
Parameters:
|
|
tiRoot_t *ptiRoot (IN) Pointer to driver root data structure
|
|
S08 *key (IN) Pointer to 1st level parameter
|
|
S08 *subkey1 (IN) Pointer to 2nd level parameter
|
|
S08 *subkey2 (IN) Pointer to 3rd level parameter
|
|
S08 *subkey3 (IN) Pointer to 4th level parameter
|
|
S08 *subkey4 (IN) Pointer to 5th level parameter
|
|
S08 *subkey5 (IN) Pointer to 6th level parameter
|
|
S08 *valueName (IN) Pointer to name of the value under keys
|
|
S08 *buffer (OUT) Pointer to returned information buffer
|
|
U32 bufferLen (OUT) Buffer length
|
|
U32 *lenReceived (OUT) String length in the buffer
|
|
Return:
|
|
tiSuccess - Success
|
|
Other - Failed
|
|
Note:
|
|
The scheme of searching adjustable parameter tree is the following:
|
|
key
|
|
- subkey1
|
|
- subkey2
|
|
- subkey3
|
|
- subkey4
|
|
- subkey5
|
|
- value
|
|
If no match in any case, tiError will return with zero length.
|
|
|
|
Where there is no indication of max key and subkey length,
|
|
an upper limit guess of 200 is used.
|
|
Perhaps a prudent revision would be to add some argument(s) to be
|
|
able to manage/check these "key" string lengths.
|
|
This function does no checking of buffer being a valid pointer.
|
|
*****************************************************************************/
|
|
U32 ostiGetTransportParam( tiRoot_t *ptiRoot,
|
|
S08 *key,
|
|
S08 *subkey1,
|
|
S08 *subkey2,
|
|
S08 *subkey3,
|
|
S08 *subkey4,
|
|
S08 *subkey5,
|
|
S08 *valueName,
|
|
S08 *buffer,
|
|
U32 bufferLen,
|
|
U32 *lenReceived )
|
|
{
|
|
S08 lFullKey[200];
|
|
U32 lLenFullKey = 0;
|
|
*lenReceived = 0;
|
|
|
|
if( bufferLen > 1 )
|
|
strcpy( buffer, "" );
|
|
else {
|
|
printf( "ostiGetTransportParam: buffer too small at only %d",
|
|
bufferLen );
|
|
return tiError; // not a reasonable buffer to work with
|
|
}
|
|
ostiMakeParamString( key, subkey1, subkey2, subkey3, subkey4, subkey5,
|
|
valueName, lFullKey, &lLenFullKey );
|
|
if( lLenFullKey ) // clean ParamString extraction
|
|
TUNABLE_STR_FETCH( lFullKey, buffer, bufferLen );
|
|
else
|
|
return tiError; // not working out, bail now
|
|
|
|
*lenReceived = strlen( buffer );
|
|
|
|
//if( *lenReceived ) // handy debug print
|
|
// printf( "ostiGetTransportParam: sz%d val:%s hdl-str:%s\n",
|
|
// *lenReceived, buffer, lFullKey );
|
|
|
|
return tiSuccess; // ship it chief
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
ostiIOCTLClearSignal()
|
|
|
|
Purpose:
|
|
Function to clear or reset semaphore during ioctl
|
|
Parameters:
|
|
tiRoot_t *ptiRoot (IN) Pointer to the current HBA
|
|
void **agParam1 (IN_OUT) Pointer to context to be passed
|
|
void **agParam2 (IN_OUT) Pointer to context to be passed
|
|
void **agParam (IN_OUT) Pointer to context to be passed
|
|
Return:
|
|
Note:
|
|
TBD, need more work for card based semaphore. Also needs to
|
|
consider the calling sequence.
|
|
******************************************************************************/
|
|
osGLOBAL void
|
|
ostiIOCTLClearSignal(tiRoot_t *ptiRoot,
|
|
void **agParam1,
|
|
void **agParam2,
|
|
void **agParam3)
|
|
{
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
ostiIOCTLSetSignal() ### function currently stubbed out
|
|
Purpose:
|
|
Function to set semaphore during ioctl
|
|
Parameters:
|
|
tiRoot_t *ptiRoot (IN) Pointer to the current HBA
|
|
void **agParam1 (IN_OUT) Pointer to context to be passed
|
|
void **agParam2 (IN_OUT) Pointer to context to be passed
|
|
void **agParam (IN_OUT) Pointer to context to be passed
|
|
Return:
|
|
Note:
|
|
******************************************************************************/
|
|
osGLOBAL void
|
|
ostiIOCTLSetSignal(tiRoot_t *ptiRoot,
|
|
void *agParam1,
|
|
void *agParam2,
|
|
void *agParam3)
|
|
{
|
|
struct agtiapi_softc *pCard;
|
|
pCard = TIROOT_TO_CARD(ptiRoot);
|
|
if (pCard->down_count != pCard->up_count)
|
|
{
|
|
pCard->up_count++;
|
|
sema_post (pCard->pIoctlSem);
|
|
}
|
|
}
|
|
|
|
osGLOBAL void
|
|
ostiIOCTLComplete(tiRoot_t *ptiRoot,
|
|
void *agParam1,
|
|
void *agParam2,
|
|
void *agParam3)
|
|
{
|
|
struct agtiapi_softc *pCard;
|
|
pCard = TIROOT_TO_CARD(ptiRoot);
|
|
if (pCard->down_count != pCard->up_count)
|
|
{
|
|
pCard->up_count++;
|
|
sema_post (pCard->pIoctlSem);
|
|
}
|
|
}
|
|
|
|
/******************************************************************************
|
|
ostiPortEvent()
|
|
Purpose:
|
|
Call back function to inform OS the events of port state change.
|
|
Parameters:
|
|
tiRoot_t *ptiRoot(IN) Pointer to driver root data structure
|
|
tiPortEvent_t eventType (IN) Type of port event:
|
|
tiPortPanic
|
|
tiPortResetComplete
|
|
tiPortNameServerDown
|
|
tiPortLinkDown
|
|
tiPortLinkUp
|
|
tiPortStarted
|
|
tiPortStopped
|
|
tiPortShutdown
|
|
tiPortInitComplete
|
|
void *pParm(IN) Pointer to event specific structure
|
|
Return:
|
|
None
|
|
******************************************************************************/
|
|
void
|
|
ostiPortEvent(tiRoot_t *ptiRoot,
|
|
tiPortEvent_t eventType,
|
|
U32 status,
|
|
void *pParm)
|
|
{
|
|
struct agtiapi_softc *pCard;
|
|
ag_portal_data_t *pPortalData;
|
|
|
|
AGTIAPI_PRINTK("ostiPortEvent: start eventType 0x%x\n", eventType);
|
|
|
|
pCard = TIROOT_TO_CARD(ptiRoot);
|
|
|
|
switch (eventType)
|
|
{
|
|
case tiPortStarted:
|
|
pCard->flags |= AGTIAPI_CB_DONE;
|
|
pPortalData = PORTAL_CONTEXT_TO_PORTALDATA(pParm);
|
|
PORTAL_STATUS(pPortalData) |= AGTIAPI_PORT_START;
|
|
AGTIAPI_PRINTK("PortStarted - portal %p, status %x\n",
|
|
pPortalData, PORTAL_STATUS(pPortalData));
|
|
break;
|
|
case tiPortLinkDown:
|
|
pPortalData = PORTAL_CONTEXT_TO_PORTALDATA(pParm);
|
|
PORTAL_STATUS(pPortalData) &= ~AGTIAPI_PORT_LINK_UP;
|
|
AGTIAPI_PRINTK("PortLinkDown - portal %p\n", pPortalData);
|
|
break;
|
|
case tiPortLinkUp:
|
|
pPortalData = PORTAL_CONTEXT_TO_PORTALDATA(pParm);
|
|
PORTAL_STATUS(pPortalData) |= AGTIAPI_PORT_LINK_UP;
|
|
AGTIAPI_PRINTK("PortLinkUp - portal %p\n", pPortalData);
|
|
#ifdef INITIATOR_DRIVER
|
|
#ifndef HOTPLUG_SUPPORT
|
|
if (!(pCard->flags & AGTIAPI_INIT_TIME))
|
|
#endif
|
|
// agtiapi_StartIO(pCard);
|
|
#endif
|
|
break;
|
|
case tiPortDiscoveryReady:
|
|
pCard->flags |= AGTIAPI_CB_DONE;
|
|
pPortalData = PORTAL_CONTEXT_TO_PORTALDATA(pParm);
|
|
PORTAL_STATUS(pPortalData) |= AGTIAPI_PORT_DISC_READY;
|
|
AGTIAPI_PRINTK("PortDiscoveryReady - portal %p, status 0x%x\n",
|
|
pPortalData, PORTAL_STATUS(pPortalData));
|
|
#ifdef INITIATOR_DRIVER
|
|
#ifndef HOTPLUG_SUPPORT
|
|
if (!(pCard->flags & AGTIAPI_INIT_TIME))
|
|
#endif
|
|
tiINIDiscoverTargets(&pCard->tiRoot,
|
|
&pPortalData->portalInfo.tiPortalContext,
|
|
FORCE_PERSISTENT_ASSIGN_MASK);
|
|
#endif
|
|
break;
|
|
case tiPortNameServerDown:
|
|
AGTIAPI_PRINTK("PortNameSeverDown\n");
|
|
pPortalData = PORTAL_CONTEXT_TO_PORTALDATA(pParm);
|
|
PORTAL_STATUS(pPortalData) &= ~AGTIAPI_NAME_SERVER_UP;
|
|
break;
|
|
case tiPortPanic:
|
|
AGTIAPI_PRINTK("PortPanic\n");
|
|
AGTIAPI_PRINTK( "## PortEvent\n" );
|
|
pCard->flags |= AGTIAPI_PORT_PANIC;
|
|
break;
|
|
case tiPortResetComplete:
|
|
AGTIAPI_PRINTK("PortResetComplete\n");
|
|
pCard->flags |= AGTIAPI_CB_DONE;
|
|
if (status == tiSuccess)
|
|
pCard->flags |= AGTIAPI_RESET_SUCCESS;
|
|
break;
|
|
case tiPortShutdown:
|
|
AGTIAPI_PRINTK("PortShutdown\n");
|
|
pCard->flags |= AGTIAPI_CB_DONE;
|
|
pCard->flags |= AGTIAPI_PORT_SHUTDOWN;
|
|
break;
|
|
case tiPortStopped:
|
|
pCard->flags |= AGTIAPI_CB_DONE;
|
|
pPortalData = PORTAL_CONTEXT_TO_PORTALDATA(pParm);
|
|
PORTAL_STATUS(pPortalData) |= AGTIAPI_PORT_STOPPED;
|
|
AGTIAPI_PRINTK("PortStopped - portal %p\n", pPortalData);
|
|
break;
|
|
case tiEncryptOperation:
|
|
break;
|
|
case tiModePageOperation:
|
|
break;
|
|
default:
|
|
AGTIAPI_PRINTK("PortEvent - %d (Unknown)\n", eventType);
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
ostiStallThread()
|
|
Purpose:
|
|
Stall the thread (busy wait) for a number of microseconds.
|
|
Parameters:
|
|
tiRoot_t *ptiRoot (IN) Pointer to the tiRoot data structure
|
|
U32 microseconds (IN) Micro-seconds to be hold
|
|
Returns: none
|
|
******************************************************************************/
|
|
void ostiStallThread( tiRoot_t *ptiRoot, U32 microseconds )
|
|
{
|
|
DELAY( microseconds );
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
ostiTimeStamp() ### stubbed out for now
|
|
Purpose:
|
|
Time stamp
|
|
Parameters:
|
|
tiRoot_t *ptiRoot (IN) Pointer to the tiRoot data structure
|
|
Returns:
|
|
Time stamp in milisecond
|
|
******************************************************************************/
|
|
U32
|
|
ostiTimeStamp(tiRoot_t *ptiRoot)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
// meant as stubbed out 64 bit version.
|
|
U64 ostiTimeStamp64( tiRoot_t *ptiRoot )
|
|
{
|
|
U64 retVal;
|
|
retVal = ostiTimeStamp( ptiRoot );
|
|
return retVal;
|
|
}
|
|
|
|
/******************************************************************************
|
|
ostiCacheFlush() ### stubbed out for now
|
|
ostiCacheInvalidate()
|
|
ostiCachePreFlush()
|
|
|
|
Purpose:
|
|
Cache-coherency APIs
|
|
Parameters:
|
|
|
|
Returns:
|
|
|
|
Note:
|
|
These 3 functions are to support new cache coherency applications.
|
|
Currently the APIs are implemented in FC for PPC platform. The
|
|
define CACHED_DMA enable for dma_cache_sync function call. However
|
|
this define is restricted for certain version of linux, such as
|
|
Linux 2.6.x and above, and certain platform such as PPC.
|
|
|
|
DO NOT define the CACHED_DMA if the cache coherency is not required
|
|
or the environment does not match.
|
|
******************************************************************************/
|
|
osGLOBAL void ostiCacheFlush(
|
|
tiRoot_t *ptiRoot,
|
|
void *osMemHandle,
|
|
void *virtPtr,
|
|
bit32 length
|
|
)
|
|
{
|
|
}
|
|
|
|
osGLOBAL void ostiCacheInvalidate(
|
|
tiRoot_t *ptiRoot,
|
|
void *osMemHandle,
|
|
void *virtPtr,
|
|
bit32 length
|
|
)
|
|
{
|
|
}
|
|
|
|
osGLOBAL void ostiCachePreFlush(
|
|
tiRoot_t *tiRoot,
|
|
void *osMemHandle,
|
|
void *virtPtr,
|
|
bit32 length
|
|
)
|
|
{
|
|
}
|
|
|
|
|
|
/*
|
|
added for SAS/SATA
|
|
this is called by ossaInterrruptEnable
|
|
*/
|
|
GLOBAL void ostiInterruptEnable( tiRoot_t *ptiRoot, bit32 channelNum )
|
|
{
|
|
// yep, really nothing.
|
|
}
|
|
|
|
/*
|
|
this is called by ossaInterrruptDisable
|
|
*/
|
|
GLOBAL void ostiInterruptDisable( tiRoot_t *ptiRoot, bit32 channelNum )
|
|
{
|
|
// yep, really nothing.
|
|
}
|
|
|