bestcomm_api.h

Go to the documentation of this file.

#ifndef __BESTCOMM_API_H
#define __BESTCOMM_API_H 1
 
/******************************************************************************
*
* Copyright (c) 2004 Freescale Semiconductor, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
******************************************************************************/
 
#include <rtems.h>
 
#include "include/ppctypes.h"
#include "include/mgt5200/sdma.h"
#include "task_api/tasksetup_bdtable.h"
#include "task_api/bestcomm_cntrl.h"
#include "task_api/bestcomm_api_mem.h"
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
#define DEBUG_BESTCOMM_API 0
 
#define MAX_TASKS 16
 
/*
 * This may need to be removed in certain implementations.
 */
#ifndef NULL
# define NULL ((void *)0)
#endif  /* NULL */
 
typedef sint8 TaskId;
typedef sint32 BDIdx;
 
/*
 * Special "task IDs" for interrupt handling API functions
 */
#define DEBUG_INTR_ID   SDMA_INT_BIT_DBG
 
#define TEA_INTR_ID     SDMA_INT_BIT_TEA
 
#define TASK_AUTOSTART_ENABLE   1
 
#define TASK_AUTOSTART_DISABLE  0
 
#define TASK_INTERRUPT_ENABLE   1
 
#define TASK_INTERRUPT_DISABLE  0
 
/*
 * Buffer descriptor flags to pass to TaskBDAssign().
 */
#define TASK_BD_TFD (1 << SDMA_DRD_BIT_TFD)
 
#define TASK_BD_INT (1 << SDMA_DRD_BIT_INT)
 
typedef enum {
    SZ_FLEX     = 3,    
    SZ_UINT8    = 1,    
    SZ_UINT16   = 2,    
    SZ_UINT32   = 4     
} Sz_t;
 
typedef enum {
    TASK_ERR_NO_ERR         = -1,   
    TASK_ERR_NO_INTR        = TASK_ERR_NO_ERR,
    TASK_ERR_INVALID_ARG    = -2,   
    TASK_ERR_BD_RING_FULL   = -3,   
    TASK_ERR_API_ALREADY_INITIALIZED
                            = -4,   
    TASK_ERR_SIZE_TOO_LARGE = -5,   
    TASK_ERR_BD_RING_EMPTY  = -6,   
    TASK_ERR_BD_BUSY        = -7,   
    TASK_ERR_TASK_RUNNING   = -8    
} TaskErr_t;
 
typedef enum {
 
    INITIATOR_ALWAYS    =  0,
    INITIATOR_SCTMR_0   =  1,
    INITIATOR_SCTMR_1   =  2,
    INITIATOR_FEC_RX    =  3,
    INITIATOR_FEC_TX    =  4,
    INITIATOR_ATA_RX    =  5,
    INITIATOR_ATA_TX    =  6,
    INITIATOR_SCPCI_RX  =  7,
    INITIATOR_SCPCI_TX  =  8,
    INITIATOR_PSC3_RX   =  9,
    INITIATOR_PSC3_TX   = 10,
    INITIATOR_PSC2_RX   = 11,
    INITIATOR_PSC2_TX   = 12,
    INITIATOR_PSC1_RX   = 13,
    INITIATOR_PSC1_TX   = 14,
    INITIATOR_SCTMR_2   = 15,
 
    INITIATOR_SCLPC     = 16,
    INITIATOR_PSC5_RX   = 17,
    INITIATOR_PSC5_TX   = 18,
    INITIATOR_PSC4_RX   = 19,
    INITIATOR_PSC4_TX   = 20,
    INITIATOR_I2C2_RX   = 21,
    INITIATOR_I2C2_TX   = 22,
    INITIATOR_I2C1_RX   = 23,
    INITIATOR_I2C1_TX   = 24,
    INITIATOR_PSC6_RX   = 25,
    INITIATOR_PSC6_TX   = 26,
    INITIATOR_IRDA_RX   = 25,
    INITIATOR_IRDA_TX   = 26,
    INITIATOR_SCTMR_3   = 27,
    INITIATOR_SCTMR_4   = 28,
    INITIATOR_SCTMR_5   = 29,
    INITIATOR_SCTMR_6   = 30,
    INITIATOR_SCTMR_7   = 31
 
} MPC5200Initiator_t;
 
typedef struct {
    uint32  NumBD;          
    union {
       uint32 MaxBuf;       
       uint32 NumBytes;     
    } Size;                 
    MPC5200Initiator_t
            Initiator;      
    uint32  StartAddrSrc;   
    sint16  IncrSrc;        
    Sz_t    SzSrc;          
    uint32  StartAddrDst;   
    sint16  IncrDst;        
    Sz_t    SzDst;          
} TaskSetupParamSet_t;
 
typedef struct {
    int dummy;              /* Some compilers don't like empty struct typedefs */
} TaskDebugParamSet_t;
 
typedef struct {
    uint32 Status;          
} TaskBD_t;
 
typedef struct {
    uint32 Status;          
    uint32 DataPtr[1];      
} TaskBD1_t;
 
typedef struct {
    uint32 Status;          
    uint32 DataPtr[2];      
} TaskBD2_t;
 
 
 
/***************************
 * Start of API Prototypes
 ***************************/
 
#include "bestcomm_priv.h"
#include "dma_image.capi.h"
 
#define         TaskSetupHelper(TaskName, TaskSetupParams)  \
                TaskSetup_ ## TaskName (TaskName ## _api, TaskSetupParams)
#define         TaskSetup(TaskName, TaskSetupParams) \
                TaskSetupHelper(TaskName, TaskSetupParams)
 
const char      *TaskVersion(void);
 
int             TasksInitAPI(uint8 *MBarRef);
 
int             TasksInitAPI_VM(uint8 *MBarRef, uint8 *MBarPhys);
 
void            TasksLoadImage(sdma_regs *sdma);
int             TasksAttachImage(sdma_regs *sdma);
 
int             TaskStart(TaskId taskId, uint32 autoStartEnable,
                          TaskId autoStartTask, uint32 intrEnable);
int             TaskStop(TaskId taskId);
static int      TaskStatus(TaskId taskId);
BDIdx           TaskBDAssign(TaskId taskId, void *buffer0, void *buffer1,
                             int size, uint32 bdFlags);
BDIdx           TaskBDRelease(TaskId taskId);
BDIdx           TaskBDReset(TaskId taskId);
static TaskBD_t *TaskGetBD(TaskId taskId, BDIdx bd);
static TaskBD_t *TaskGetBDRing(TaskId taskId);
int             TaskDebug(TaskId taskId, TaskDebugParamSet_t *paramSet);
static int      TaskIntClear(TaskId taskId);
static TaskId   TaskIntStatus(TaskId taskId);
static int      TaskIntPending(TaskId taskId);
static TaskId   TaskIntSource(void);
static uint16   TaskBDInUse(TaskId taskId);
 
 
static inline int TaskStatus(TaskId taskId)
{
    return SDMA_TASK_STATUS(SDMA_TCR, taskId) & 0x8000;
}
 
static inline TaskBD_t *TaskGetBD(TaskId taskId, BDIdx bd)
{
    void *bdTab;
 
    bdTab = TaskBDIdxTable[taskId].BDTablePtr;
    if (TaskBDIdxTable[taskId].numPtr == 1) {
        return (TaskBD_t *)&(((TaskBD1_t *)bdTab)[bd]);
    } else {
        return (TaskBD_t *)&(((TaskBD2_t *)bdTab)[bd]);
    }
}
 
static inline TaskBD_t *TaskGetBDRing(TaskId taskId)
{
    return (TaskBD_t *) TaskBDIdxTable[taskId].BDTablePtr;
}
 
static inline int TaskIntClear(TaskId taskId)
{
    SDMA_CLEAR_IEVENT(SDMA_INT_PEND, taskId);
    return TASK_ERR_NO_ERR; /* success */
}
 
static inline TaskId TaskIntStatus(TaskId taskId)
{
    uint32 pending;
 
    pending = SDMA_INT_PENDING(SDMA_INT_PEND, SDMA_INT_MASK);
 
    if (SDMA_INT_TEST(pending, taskId)) {
        return taskId;
    } else if (SDMA_INT_TEST(pending, DEBUG_INTR_ID)) {
        return DEBUG_INTR_ID;
    } else if (SDMA_INT_TEST(pending, TEA_INTR_ID)) {
        return TEA_INTR_ID;
    }
 
    return TASK_ERR_NO_INTR;
}
 
static inline int TaskIntPending(TaskId taskId)
{
    uint32 pending;
 
    pending = SDMA_INT_PENDING(SDMA_INT_PEND, SDMA_INT_MASK);
    if (SDMA_INT_TEST(pending, taskId)) {
        return 1;
    } else {
        return 0;
    }
}
 
static inline TaskId TaskIntSource(void)
{
    uint32 pending;
    uint32 mask = 1 << (MAX_TASKS - 1);
    TaskId i;
 
    pending = SDMA_INT_PENDING(SDMA_INT_PEND, SDMA_INT_MASK);
 
    if (SDMA_INT_TEST(pending, SDMA_INT_BIT_TEA)) {
        return (TaskId)SDMA_TEA_SOURCE(SDMA_INT_PEND);
    }
 
    for (i = (MAX_TASKS - 1); i >= 0; --i, mask >>= 1) {
        if (pending & mask) {
            return i;
        }
    }
 
    return TASK_ERR_NO_INTR;
}
 
static inline uint16 TaskBDInUse(TaskId taskId)
{
    return TaskBDIdxTable[taskId].currBDInUse;
}
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
 
#endif  /* __BESTCOMM_API_H */