can.cpp

SMDK2410_ZY_V11.rar

			SJA1000_REGISTER_WRITE(MOD, (regMod | MOD_STM) & ~MOD_RM);
			break;
		}
		bError = TRUE;
		break;}
	case IOCTL_SET_CAN_FILTER: {
		UINT32* Filter = (UINT32*)pBufIn;
		SJA1000_SetFilter(Filter[0], Filter[1]);
		bError = TRUE;
		break;}
	}

    DEBUGMSG (ZONE_FUNCTION, (TEXT("- ")TEXT(__FUNCTION__)TEXT("\r\n")));
	return bError;
}

/*******************************************************************************
函数名称: CAN_Read
输入参数: DWORD Handle    : 驱动程序引用事例句柄
          LPVOID pBuffer  : 接收缓冲区
          DWORD dwNumBytes: 要读的字节数
输出参数: 无
返    回: 实际读到字节数
*******************************************************************************/

DWORD CAN_Read(DWORD hOpenContext, LPVOID pBuffer, DWORD Count)
{
    DEBUGMSG (ZONE_FUNCTION, (TEXT("+ ")TEXT(__FUNCTION__)TEXT("\r\n")));

	if (!g_OpenCount) return 0;

	DWORD dwRet;
	LPCVOID pReadBuffer;

	if ((pBuffer == NULL) || (Count <= 0))
		return 0;

	pReadBuffer = MapPtrToProcess((UCHAR *)pBuffer, GetCallerProcess());

	dwRet = WaitForSingleObject(g_hRxEvent, CAN_RW_TIMEOUT);
	if ((dwRet == WAIT_TIMEOUT) || g_bKillIST || !g_OpenCount) 
		return 0;
	ResetEvent(g_hRxEvent);

	memcpy(pBuffer, &g_rxMsg, sizeof(CAN_MSG));

    DEBUGMSG (ZONE_FUNCTION, (TEXT("- ")TEXT(__FUNCTION__)TEXT("\r\n")));
	return Count;
}

/*******************************************************************************
函数名称: CAN_Write
描    述: 向 IIC 从机发送数据
输入参数: 
输出参数:
返    回: 成功发送的字节数
*******************************************************************************/

DWORD CAN_Write(DWORD hOpenContext, LPCVOID pBuffer, DWORD Count)
{
    DEBUGMSG (ZONE_FUNCTION, (TEXT("+ ")TEXT(__FUNCTION__)TEXT("\r\n")));

	if (!g_OpenCount) return 0;

	DWORD dwRet;
	LPCVOID pWriteBuffer;

	if ((pBuffer == NULL) || (Count <= 0))
		return 0;

	pWriteBuffer = MapPtrToProcess((UCHAR *)pBuffer, GetCallerProcess());

	dwRet = WaitForSingleObject(g_hTxEvent, CAN_RW_TIMEOUT);
	if (dwRet == WAIT_TIMEOUT)
	{
		SJA1000_REGISTER_WRITE(CMR, CMR_AT);	// 取消发送
		return 0;
	}
	ResetEvent(g_hTxEvent);

	SJA1000_MsgWrite((CAN_MSG *)pWriteBuffer);
    SJA1000_REGISTER_WRITE(CMR, g_regCmd);	// 启动发送

    DEBUGMSG (ZONE_FUNCTION, (TEXT("- ")TEXT(__FUNCTION__)TEXT("\r\n")));
	return Count;
}

/*******************************************************************************
函数名称: CAN_PowerUp
描    述: 电源上电驱动处理函数
输入参数: 
输出参数:
返    回: 无
*******************************************************************************/

void CAN_PowerUp(DWORD hDeviceContext)
{
    DEBUGMSG (ZONE_FUNCTION, (TEXT("+ ")TEXT(__FUNCTION__)TEXT("\r\n")));
    DEBUGMSG (ZONE_FUNCTION, (TEXT("- ")TEXT(__FUNCTION__)TEXT("\r\n")));
}

/*******************************************************************************
函数名称: CAN_PowerDown
描    述: 电源下电驱动处理函数
输入参数: 
输出参数:
返    回: 无
*******************************************************************************/

void CAN_PowerDown(DWORD hDeviceContext)
{
    DEBUGMSG (ZONE_FUNCTION, (TEXT("+ ")TEXT(__FUNCTION__)TEXT("\r\n")));
    DEBUGMSG (ZONE_FUNCTION, (TEXT("- ")TEXT(__FUNCTION__)TEXT("\r\n")));
}

/*******************************************************************************
函数名称: CAN_IntrThread
描	  述: I2C 中断服务线程
输入参数: PVOID pArg:  	线程输入参数	
输出参数: 无
返    回: 1 或 0
*******************************************************************************/

static DWORD WINAPI CAN_IntrThread(LPVOID pContext)
{
	DWORD dwRet;

	// 初始化 I2C 中断: 注册中断事件, 允许 I2C 中断
	if (!(InterruptInitialize(g_nCanSysIntr, g_hInterrupt, 0, 0))) 
	{
		DEB_0(ZONE_THREAD, _T(" Interrupt initialize failed\r"));
		return 0;
	}

	// IIC 中断线程开始运行
	while (!g_bKillIST) 
	{
		dwRet = WaitForSingleObject(g_hInterrupt, INFINITE);
		if (g_bKillIST == TRUE)
			return 0;

		UINT8 regInt;
		SJA1000_REGISTER_READ(IR, regInt);

		if (regInt == 0) continue;
		if (regInt & IR_RI)
		{
			SJA1000_MsgRead(&g_rxMsg);
			SJA1000_REGISTER_WRITE(CMR, CMR_RRB);
			SetEvent(g_hRxEvent);
		}
		if (regInt & IR_TI)
		{
			SetEvent(g_hTxEvent);
		}
		if (regInt & IR_DOI)
		{
			SJA1000_REGISTER_WRITE(CMR, CMR_CDO);
		}
		else
		{
			// TODO:处理错误事件，在本例子中忽略这一步
		}

		DEB_1(ZONE_THREAD, _T(" ----> CAN_IntrThread: %2.2X\r"), regInt);
		InterruptDone(g_nCanSysIntr);
	}

	DEB_0(ZONE_THREAD, _T(" exiting IST\r"));
	return 0;
}

///////////////////////////////////////////////////////////////////////////////

void SJA1000_ReadRegister(UINT8 reg, UINT8 *value)
{
	//g_lpBaseSJA1000[8] = reg;
	//*value = (UINT8)g_lpBaseSJA1000[4];

	WRITE_REGISTER_UCHAR((PUCHAR)&g_lpBaseSJA1000[8], reg);
	*value = READ_REGISTER_UCHAR((PUCHAR)&g_lpBaseSJA1000[4]);
}

void SJA1000_WriteRegister(UINT8 reg, UINT8 value)
{
	//g_lpBaseSJA1000[4] = reg;
	//g_lpBaseSJA1000[8] = value;

	WRITE_REGISTER_UCHAR((PUCHAR)&g_lpBaseSJA1000[8], reg);
	WRITE_REGISTER_UCHAR((PUCHAR)&g_lpBaseSJA1000[4], value);
}

/*******************************************************************************
函数名称: EINT_ConfigInterruptPin
描    述: 配置外部中断引脚并使能为 下降 沿触发
输入参数: 无	
输出参数: 无
返    回: 无
*******************************************************************************/

VOID EINT_ConfigInterruptPin(VOID)
{
	g_lpBaseEXINT->GPFCON  &= ~(0x3 << 10);		// Set EINT5(GPF5) as EINT5
	g_lpBaseEXINT->GPFCON  |=  (0x2 << 10);

    g_lpBaseEXINT->EXTINT0 &= ~(0x7 << 20);		// falling edge tiggered Mode
    g_lpBaseEXINT->EXTINT0 |=  (0x2 << 20);
}

/*******************************************************************************
函数名称: SJA1000_Init
描    述: 初始化 SJA1000
输入参数: 无	
输出参数: 无
返    回: 无
*******************************************************************************/

void SJA1000_Init()
{
	UINT8 regval;

    SJA1000_REGISTER_WRITE(CDR, CDR_PELICAN | CDR_CBP | CDR_CLKOFF);

	SJA1000_REGISTER_READ(IER, regval);
	regval &= ~(IER_RIE | IER_TIE | IER_EIE | IER_DOIE | IER_WUIE | 
				IER_EPIE | IER_ALIE | IER_BEIE);
	 SJA1000_REGISTER_WRITE(IER, regval);

	/*
	configure CAN outputs: float on TX1, Push/Pull on TX0,
	normal output mode
	*/
	SJA1000_REGISTER_WRITE(OCR, OCMODE_NORMAL | TX0_PUSHPULL | TX1_FLOAR);

    /* now reset the error counter register */

	SJA1000_REGISTER_WRITE(RXERR, 0);
	SJA1000_REGISTER_WRITE(TXERR, 0);

	SJA1000_REGISTER_WRITE(EWL, 0x80);

	/* read this register for clean the identification of interrupts */

	SJA1000_REGISTER_READ(IR, regval);

	SJA1000_REGISTER_READ(MOD, regval);
	SJA1000_REGISTER_WRITE(MOD, regval | MOD_RM| MOD_AFM);
	g_regCmd = CMR_TR;
}

/*******************************************************************************
函数名称: SJA1000_SetFilter
描    述: 设置 SJA1000 过滤器
输入参数: 无	
输出参数: 无
返    回: 无
*******************************************************************************/

void SJA1000_SetFilter(UINT32 ACRCode, UINT32 AMRCode)
{
	UINT8 regMod;
	UINT8 *regAcr = (UINT8 *)&ACRCode;
	UINT8 *regAmr = (UINT8 *)&AMRCode;

	SJA1000_REGISTER_READ(MOD, regMod);
	SJA1000_REGISTER_WRITE(MOD, regMod | MOD_RM);

	SJA1000_REGISTER_WRITE(ACR,     regAcr[0]);
	SJA1000_REGISTER_WRITE(ACR + 1, regAcr[1]);
	SJA1000_REGISTER_WRITE(ACR + 2, regAcr[2]);
	SJA1000_REGISTER_WRITE(ACR + 3, regAcr[3]);

	SJA1000_REGISTER_WRITE(MCR,     regAmr[0]);
	SJA1000_REGISTER_WRITE(MCR + 1, regAmr[1]);
	SJA1000_REGISTER_WRITE(MCR + 2, regAmr[2]);
	SJA1000_REGISTER_WRITE(MCR + 3, regAmr[3]);

	DEB_4(ZONE_THREAD, _T(" AMRCode: %2.2X %2.2X %2.2X %2.2X\r"), 
		regAmr[0],regAmr[1],regAmr[2],regAmr[3]);

	SJA1000_REGISTER_WRITE(MOD, regMod | MOD_AFM); // 单滤波模式
}

/*******************************************************************************
函数名称: SJA1000_BaudSet
描    述: 设置 SJA1000 的波特率
输入参数: 无	
输出参数: 无
返    回: 无
*******************************************************************************/

void SJA1000_BaudSet(UINT8 BTR[])
{
	UINT8 regMod;
	
	SJA1000_REGISTER_READ(MOD, regMod);
	if (regMod & MOD_RM)
	{
		SJA1000_REGISTER_WRITE(BTR0, BTR[0]);
		SJA1000_REGISTER_WRITE(BTR1, BTR[1]);
	}
	else
	{
		SJA1000_REGISTER_WRITE(MOD, regMod | MOD_RM);

		SJA1000_REGISTER_WRITE(BTR0, BTR[0]);
		SJA1000_REGISTER_WRITE(BTR1, BTR[1]);

		SJA1000_REGISTER_WRITE(MOD, regMod);
	}
}

/*******************************************************************************
函数名称: SJA1000_MsgWrite
描    述: 写 SJA1000 发送缓冲
输入参数: 无	
输出参数: 无
返    回: 无
*******************************************************************************/

void SJA1000_MsgWrite(CAN_MSG *pMsg)
{
	int i = 7;

	SJA1000_REGISTER_WRITE(TXINFO, pMsg->info);

	if (pMsg->format == 0)	/* standard frame format */
	{
		pMsg->identifier <<= 5;

		SJA1000_REGISTER_WRITE(TXBUF + 0, pMsg->id[1]);
		SJA1000_REGISTER_WRITE(TXBUF + 1, pMsg->id[0]);

		while (i > 0)
		{
			SJA1000_REGISTER_WRITE(TXBUF + 2 + i, pMsg->data[i--]);
			SJA1000_REGISTER_WRITE(TXBUF + 2 + i, pMsg->data[i--]);
		}
	}
	else	/* extended frame format */
	{
		pMsg->identifier <<= 3;

		SJA1000_REGISTER_WRITE(TXBUF + 0, pMsg->id[3]);
		SJA1000_REGISTER_WRITE(TXBUF + 1, pMsg->id[2]);
		SJA1000_REGISTER_WRITE(TXBUF + 2, pMsg->id[1]);
		SJA1000_REGISTER_WRITE(TXBUF + 3, pMsg->id[0]);

		while (i > 0)
		{
			SJA1000_REGISTER_WRITE(TXBUF + 4 + i, pMsg->data[i--]);
			SJA1000_REGISTER_WRITE(TXBUF + 4 + i, pMsg->data[i--]);
		}
	}
}

/*******************************************************************************
函数名称: SJA1000_MsgRead
描    述: 读 SJA1000 接收缓冲
输入参数: 无	
输出参数: 无
返    回: 无
*******************************************************************************/

void SJA1000_MsgRead(CAN_MSG *pMsg)
{
	int i = 7;

	SJA1000_REGISTER_READ(RXINFO, pMsg->info);

	if (pMsg->format == 0)	/* standard frame format */
	{
		SJA1000_REGISTER_READ(RXBUF + 1, pMsg->id[0]);
		SJA1000_REGISTER_READ(RXBUF + 0, pMsg->id[1]);
		pMsg->id[2] = 0;
		pMsg->id[3] = 0;

		pMsg->identifier >>= 5;

		while (i > 0)
		{
			SJA1000_REGISTER_READ(RXBUF + 2 + (i--), pMsg->data[i]);
			SJA1000_REGISTER_READ(RXBUF + 2 + (i--), pMsg->data[i]);
		}
	}
	else	/* extended frame format */
	{
		SJA1000_REGISTER_READ(RXBUF + 3, pMsg->id[0]);
		SJA1000_REGISTER_READ(RXBUF + 2, pMsg->id[1]);
		SJA1000_REGISTER_READ(RXBUF + 1, pMsg->id[2]);
		SJA1000_REGISTER_READ(RXBUF + 0, pMsg->id[3]);

		pMsg->identifier >>= 3;

		while (i > 0)
		{
			SJA1000_REGISTER_READ(RXBUF + 4 + (i--), pMsg->data[i]);
			SJA1000_REGISTER_READ(RXBUF + 4 + (i--), pMsg->data[i]);
		}
	}
}