sc16is752.c

此文件为在vxworks系统下关于串口扩展芯片16IS752驱动的BSP开发

static void sc16is752irqTask(void)
{
    uchar regValue;
    int i, rst;

    FOREVER{
        rst = semTake(s_semSc16is752irqTask, 120);
        
        /* test it weather is reseted every 1 second */
        if (ERROR == rst){
            regValue = readReg(IER, CHANNEL_TYPE_A);
            if (0x00 == regValue) {
                sc16isInit();
            }
        } else {   
            for (i = 0; i < 2; i++){
                regValue = readReg(IIR, CHANNEL_TYPE_A + i);
#if 0
                logMsg("-------------irq-----[%02X]------\n\n",regValue,0,0,0,0,0);
#endif
                /* an interrupt is pending */
                if (0x00 == (regValue & 0x01)) {
                    
                    /* RHR interrupt or Receiver time-out interrupt */
                    if ((0x04 == (regValue & 0x04)) || (0x0C == (regValue & 0x0C))){
                        readSerialData(CHANNEL_TYPE_A + i);
                        
                    /* THR interrupt */
                    } else if (0x02 == (regValue & 0x02)){
                        /* To Do ... */
                        
                    /* input pin change of state */
                    } else if (0x30 == (regValue & 0x30)){
                        disposeGpioEvent();                
                    }
                }
            }
        }
        taskDelay(1);    
    }
}
/******************************************************************************
*
* disposeGpioEvent - dispose sc16is752 gpio.
*
* INPUTS:
*   void.
*
* RETURNS:
*   void.
*
******************************************************************************/
static void disposeGpioEvent(void)
{
    int i;
    uchar regValue = readReg(IOState, CHANNEL_TYPE_A);    
    uchar portState = sc16is752Reg.IoState;
    uchar IoDir = sc16is752Reg.IoDir;
        
    for (i = 0; i < 8; i++){
        if (BITS(IoDir, i) == IO_IN){
            if (BITS(portState, i) == BITS(regValue ,i)){   /* trigger only when the input io changed */
                continue;
            }            
            if ((IO_LOW == BITS(portState, i)) && (IO_HIGH == BITS(regValue ,i))){
                if (NULL != s_sc16is752IoEvent[i].pUpFunc) {                    
                    (s_sc16is752IoEvent[i].pUpFunc)(s_sc16is752IoEvent[i].iUpArg);                    
                }
            } else {                
                if (NULL != s_sc16is752IoEvent[i].pDownFunc) {                    
                    (s_sc16is752IoEvent[i].pDownFunc)(s_sc16is752IoEvent[i].iDownArg);                    
                }
            }
            SETBITS(sc16is752Reg.IoState, i, BITS(regValue ,i));/* set the bak */
        }
    }
}
/******************************************************************************
*
* getSerialData - get data from sc16is752 serial port.
*
* INPUTS:
*      uchar channel : register channel.
*
* RETURNS:
*  void.
*
******************************************************************************/
static void readSerialData(uchar channel)
{
    int iLen, i;
    uchar data;
        
    /* read data length */
    iLen = readReg(RXLVL, channel);

    /* read data */
    for (i = 0; i < iLen; i++){
        data = readReg(RHR, channel);
        rngBufPut(sc16is752Dev[channel].rngRxBuf, &data, 1);        
    }
    semGive(sc16is752Dev[channel].syncSem);
    selWakeupAll(&(sc16is752Dev[channel].selWakeupList), SELREAD);
}
/******************************************************************************
*
* sc16isInit - initiallize the sc16is752 chip.
*
* INPUTS:
*  void.
*
* RETURNS:
*  void.
*
******************************************************************************/
static void sc16isInit(void)
{
    int ix;
    
    /* clears the contents of the transmit and receive FIFO and resets the FIFO 
     * level logic and enable the transmit and receive FIFO */
    writeReg(FCR, CHANNEL_TYPE_A, 0x07);
    writeReg(FCR, CHANNEL_TYPE_B, 0x07);
    
    /* only enable the THR and RHR interrupt */
    writeReg(IER, CHANNEL_TYPE_A, 0x03);
    writeReg(IER, CHANNEL_TYPE_B, 0x03);
                         
    /* initialize sc16is752 */ 
    sc16is752Reg.IoDir   = 0xFF;/* all out put */
    sc16is752Reg.IoState = 0xFF;/* only run led aalid */
    
    /* initialize io dir */
    writeReg(IODir, CHANNEL_TYPE_A, sc16is752Reg.IoDir);
    
    /* a change in the input will generate an interrupt */    
    writeReg(IOIntEna, CHANNEL_TYPE_A, 0xFF);
    
    /* initialize out io default value */
    if (0x00 != sc16is752Reg.IoDir){
        writeReg(IOState, CHANNEL_TYPE_A, sc16is752Reg.IoState);        
    }
    
    for (ix = 0; ix < 2; ix++){
        
        /* initialize uart ftr register */
        writeReg(FCR, CHANNEL_TYPE_A + ix, sc16is752Dev[ix].fcrReg);
        
        /* initialize uart eftr register */
        writeReg(EFCR, CHANNEL_TYPE_A + ix, sc16is752Dev[ix].efcrReg);
        
        /* initialize uart moder register */
        writeReg(LCR, CHANNEL_TYPE_A + ix, sc16is752Dev[ix].moder_LCR);
        
        /* first enable the LCR[7] */	        
	    writeReg(LCR, CHANNEL_TYPE_A + ix, 0x80);
	    writeReg(DLL, CHANNEL_TYPE_A + ix, sc16is752Dev[ix].moder_DLL);
	    writeReg(DLH, CHANNEL_TYPE_A + ix, sc16is752Dev[ix].moder_DLH);
	    writeReg(LCR, CHANNEL_TYPE_A + ix, sc16is752Dev[ix].moder_LCR & 0x7F);
	}
}
/******************************************************************************
*
* writeData - write data to register.
*
* INPUTS:
*   uchar regAddr : register address.
    uchar channel : register channel.
    uchar *buf    : the data which will be sent.    
    int len       : the data length.    
*
* RETURNS:
*  void.
*
******************************************************************************/
 void writeData(uchar regAddr, uchar channel, uchar *buf, int len)
{
    if ((regAddr > 0x0F) || (channel > 1)) return;

    regAddr <<= 3;
    regAddr |= (channel << 1);
    regAddr &= 0x7F;
    
    taskLock();
    
    spi_ioctl(0,0,8,1);
    SPI_EN_SC16IS752;    
	spi_write(regAddr);
	while(len-- > 0){
        spi_write(*buf++);	
    }
	SPI_UNEN_SC16IS752;
	spi_ioctl(1,0,8,0);
	
	taskUnlock();
}
/******************************************************************************
*
* writeReg - write data to register.
*
* INPUTS:
*   uchar regAddr : register address.
    uchar channel : register channel.
    uchar regValue: register value.    
*
* RETURNS:
*  void.
*
******************************************************************************/
 void writeReg(uchar regAddr, uchar channel, uchar regValue)
{
    if ((regAddr > 0x0F) || (channel > 1)) return;

    regAddr <<= 3;
    regAddr |= (channel << 1);
    regAddr &= 0x7F;
    
    taskLock();
    
    spi_ioctl(0,0,8,1);
    SPI_EN_SC16IS752;    
	spi_write(regAddr);
	spi_write(regValue);	
	SPI_UNEN_SC16IS752;
	spi_ioctl(1,0,8,0);
	
	taskUnlock();
}
/******************************************************************************
*
* readReg - read data from register.
*
* INPUTS:
*   uchar regAddr : register address.
    uchar channel : register channel.    
*
* RETURNS:
*  uchar : register value.    
*
******************************************************************************/
 uchar readReg(uchar regAddr, uchar channel)
{
    uchar regValue;

    if ((regAddr > 0x0F) || (channel > 1)) return ERROR;

    regAddr <<= 3;
    regAddr |= (channel << 1);
    regAddr |= 0x80;
    
    taskLock();
    
    spi_ioctl(0,0,8,1);
    SPI_EN_SC16IS752;    
	spi_write(regAddr);
	spi_read(&regValue);	
	SPI_UNEN_SC16IS752;
	spi_ioctl(1,0,8,0);
	
	taskUnlock();
	return regValue;
}

/*-------------------------------TEST---------------------------------------*/
void printfInputIO(int tt)
{
	printf("Key=[%02X]\n\n", tt);
}
extern void inits(void)
{
    sc16is752_event(SC16IS752_IO_PA0, (VOIDFUNCPTR)printfInputIO, SC16IS752_IO_PA0, (VOIDFUNCPTR)printfInputIO,SC16IS752_IO_PA0);
    sc16is752_event(SC16IS752_IO_PA1, (VOIDFUNCPTR)printfInputIO, SC16IS752_IO_PA1, (VOIDFUNCPTR)printfInputIO,SC16IS752_IO_PA1);
    sc16is752_event(SC16IS752_IO_PA2, (VOIDFUNCPTR)printfInputIO, SC16IS752_IO_PA2, (VOIDFUNCPTR)printfInputIO,SC16IS752_IO_PA2);
    sc16is752_event(SC16IS752_IO_PA3, (VOIDFUNCPTR)printfInputIO, SC16IS752_IO_PA3, (VOIDFUNCPTR)printfInputIO,SC16IS752_IO_PA3);
    sc16is752_event(SC16IS752_IO_PA4, (VOIDFUNCPTR)printfInputIO, SC16IS752_IO_PA4, (VOIDFUNCPTR)printfInputIO,SC16IS752_IO_PA4);
    sc16is752_event(SC16IS752_IO_PA5, (VOIDFUNCPTR)printfInputIO, SC16IS752_IO_PA5, (VOIDFUNCPTR)printfInputIO,SC16IS752_IO_PA5);
    sc16is752_event(SC16IS752_IO_PA6, (VOIDFUNCPTR)printfInputIO, SC16IS752_IO_PA6, (VOIDFUNCPTR)printfInputIO,SC16IS752_IO_PA6);
    sc16is752_event(SC16IS752_IO_PA7, (VOIDFUNCPTR)printfInputIO, SC16IS752_IO_PA7, (VOIDFUNCPTR)printfInputIO,SC16IS752_IO_PA7);       
}
extern void printBuf(char *format,UINT8 *frame, UINT16 len)
{
	int i;

	printf(format);
	for(i = 0; i < len; i++){
		printf("%02X ", frame[i]);
	}
	printf("\n");
}
extern int serbw(int n)
{   
    int i, rst, fd;
    uchar dd[1024];
    
    fd=open("/Com/1",2,0);  
    for (i = 0; i < n; i++){
        dd[i] = n+i;
    }
    rst= write(fd,dd,n);
	close(fd);
	return rst;
}
extern int serbr(int n)
{
    int rst, fd;
    uchar dd[1024];
        
    fd=open("/Com/1",2,0);  
    bzero(dd,1024);
    rst= read(fd,dd,n);
	close(fd);
	printBuf("R-------", dd,rst);

	return rst;
}
extern int seraw(int n)
{   
    int i, rst, fd;
    uchar dd[1024];
    
    fd=open("/Com/0",2,0);  
    for (i = 0; i < n; i++){
        dd[i] = n+i;
    }
    rst= write(fd,dd,n);
	close(fd);
	return rst;
}
extern int serar(int n)
{
    int rst, fd;
    uchar dd[1024];
        
    fd=open("/Com/0",2,0);  
    bzero(dd,1024);
    rst= read(fd,dd,n);
	close(fd);
	printBuf("R-------", dd,rst);

	return rst;
}
extern int wgpio(int n, uchar m)
{
	return sc16is752_write(n,m);
}
extern int rgpio(int n)
{
	uchar p[1];

	sc16is752_read(n,p);
	return p[0];
}
/*******************************End of sc16is752.c *******************************/