s3c2410-can.c

2410 spi 外接2515 can转换 驱动代码

           printk ("clear can1  \n");
           resetcan1 = 0;
           rwflag = 1;
           MCP2515_Reset();
           MCP2515_Write(MCP2515REG_CANCTRL, MODE_CONFIG);
           ReadBackCNT = 0 ;
           while( ReadBackCNT<8 )
	    {
		value = ( MCP2515_Read( MCP2515REG_CANSTAT ) & 0xe0 );
		if(value == MODE_CONFIG )
		{
			printk( " alow reset1\n" );
			break;
		}
		
                MCP2515_Write(MCP2515REG_CANCTRL, MODE_CONFIG);
                ReadBackCNT = ReadBackCNT +1 ;
	     }
           Delay (150);
           Init1_MCP2515(BandRate_250kbps);
           inte1 = MCP2515_Read (CANINTE);
                printk ("inte1 = %d \n" , inte1);
           INTMSK &= 0xfffffffb;
          }
         MCP2515_Write(TEC, 0x00);
         MCP2515_Write(REC, 0x00);
         MCP2515_Write(EFLG, 0x00);
         //MCP2515_Write(CANINTF, 0x00);
         MCP2515_WriteBits(CANINTF, 0xfc , 0x00);
         rwflag = 0;
         clearcan1 = 0;
       }
    if (clearcan2 >= 200)
       {
         rwflag = 2;
         can2 = MCP2515_Read (EFLG);
         printk ("can2 = %d \n" , can2);
         resetcan2 = resetcan2 +1;
         if ( resetcan2 >= 4 )
          { 
           INTMSK |= 0x00000020;  //屏蔽1号can
           printk ("clear can2  \n");
           resetcan2 = 0;
           rwflag = 2;
           MCP2515_Reset();
           MCP2515_Write(MCP2515REG_CANCTRL, MODE_CONFIG);
           ReadBackCNT = 0 ;
           while( ReadBackCNT<8 )
	    {
		value = ( MCP2515_Read( MCP2515REG_CANSTAT ) & 0xe0 );
		if(value == MODE_CONFIG )
		{
			printk( " alow reset2\n" );
			break;
		}
                MCP2515_Write(MCP2515REG_CANCTRL, MODE_CONFIG);
		ReadBackCNT = ReadBackCNT +1 ;
	     }
           Delay (150);
           Init2_MCP2515(BandRate_250kbps);
           inte2 = MCP2515_Read (CANINTE);
                printk ("inte2 = %d \n" , inte2);
           INTMSK &= 0xffffffdf ;
         }
         MCP2515_Write(TEC, 0x00);
         MCP2515_Write(REC, 0x00);
         MCP2515_Write(EFLG, 0x00);
         //MCP2515_Write(CANINTF, 0x00);
         MCP2515_WriteBits(CANINTF, 0xfc , 0x00);
         rwflag = 0;
         clearcan2 = 0;
       }
   
     
     return 0;
     //GPGCON &= 0xffcfffff;   // 配置中断18
     //GPGCON |= 0x00100000; 
}


static ssize_t can_write (struct file *file, const char *buffer, size_t user_len, loff_t *offset)
{
     U8 sendbuffer [sizeof(CanData)];
     U32 id;
     U8 data[8] , dlc , number = 0 , aa = 0;
     int IsExt, rxRTR , i ;
     
     //copy_from_user(sendbuffer,buffer,sizeof(CanData));
     copy_from_user(sendbuffer,buffer,25);
     id = (sendbuffer[3]<<24) | (sendbuffer[2]<<16) | (sendbuffer[1]<<8) | (sendbuffer[0]);
     for (i=0;i<8;i++)
       data[i] = sendbuffer[i+4];
     dlc= sendbuffer[12];
     IsExt = (sendbuffer[19]<<24) | (sendbuffer[18]<<16) | (sendbuffer[17]<<8) | (sendbuffer[16]);
     rxRTR= (sendbuffer[23]<<24) | (sendbuffer[22]<<16) | (sendbuffer[21]<<8) | (sendbuffer[20]);
     number = sendbuffer[24];
     aa = sizeof(CanData);
     
     printk("aa = %d \n" , aa);
     printk("IsExt = %d \n" , IsExt);
     printk("rxRTR = %d \n" , rxRTR);
     printk("number = %d \n" , number);
     printk("sendbuffer[24] = %d \n" , sendbuffer[24]);
	printk("id = %d \n" , id);

     //Init_MCP2515(BandRate_250kbps);
     /*printk("id = %d \n" , id);
     printk("sendbuffer[0] = %d \n" , sendbuffer[0]);
     printk("sendbuffer[1] = %d \n" , sendbuffer[1]);
     printk("sendbuffer[2] = %d \n" , sendbuffer[2]);
     printk("sendbuffer[3] = %d \n" , sendbuffer[3]);*/
     
     if (number == 1)
       {
         rwflag = 1;  //从can1发送数据
         CanWrite(id, data, dlc, IsExt, rxRTR);
         rwflag = 0;
       }

     if (number == 2)
       {
         rwflag = 2;  //从can2发送数据
         CanWrite(id, data, dlc, IsExt, rxRTR);
         rwflag = 0;
       }

     return sizeof(CanData);

}

static int can_open(struct inode *inode, struct file *filp)
{
     /*if(opencount==1)
     return -EBUSY;
     opencount++;*/
	
     MOD_INC_USE_COUNT; //计数器加一
     return 0;
}

static int can_release(struct inode *inode, struct file *filp)
{
	
        
     MOD_DEC_USE_COUNT; //计数器减一
     return 0;
}

static struct file_operations s3c2410can_fops = {
	owner	:	THIS_MODULE,
	read	:	can_read,
	open	:	can_open,
        ioctl     :       can_ioctl,
	write	:	can_write,
	release	:	can_release,
};

static int __init can_init(void)
{
        U8 config1 , config2 , config3 , inte1 ,inte2 , inte3 ;
        int ret , flags;
        
	local_irq_save (flags);  //关闭所有的中断 并保存当前的状态

        /*GPBCON &= 0xffcfcfff;   //GPB6,10输出
        GPBCON |= 0x00101000;
        GPBUP  &= 0xfbbf;
        GPBDAT |= 0x0040;     //GPB6高 5v使能
        GPBDAT &= 0xfbff;     //GPB10低 12v使能
        GPBDAT |= 0x0400;     //GPB10高 12v使能
        Delay (5000);*/
	
        GPECON |= 0x0a800000;  //spi功能开启
	GPEUP  &= 0xe7ff;
        GPEUP  |= 0x2000;
        Delay (200);

        SPI_Init();
        Delay (500);
        
        //用自己的板子
        GPCCON &= 0xffff0fff;   //配置2515cs选择引脚为输出 gpc6.7 select2.3
        GPCCON |= 0x00005000;   
        GPCUP  &= 0xff3f;
 
	//can3int=gpg3	can2int=gpf2	can1int=gpg10
        GPGCON &= 0xffcfffcf;   //配置2515cs选择引脚为输出 配置中断18
        GPGCON |= 0x00100010;   
        GPGUP  &= 0xfffb;

        GPBCON &= 0xfffff3ff;   //配置2515复位选择引脚为输出
        GPBCON |= 0x00000400;
        GPBUP  &= 0xffdf;

        /*GPBDAT &=0xffdf;  //对2515进行一次复位
        Delay (50);*/
        GPBDAT |=0x0020;
        //Delay (50);
	
        while(1)
          {
            config1 = 0;
            rwflag = 1;
            MCP2515_WriteBits(CANINTF, 0x03 , 0x03);
            config1 = MCP2515_Read(MCP2515REG_CANSTAT);
            
            if ( (config1 & 0xe0) == 0x80 )
              {
	        Init1_MCP2515(BandRate_250kbps);
                Delay (50);
                rwflag = 1;
                inte1 = MCP2515_Read (CANINTE);
                printk ("inte1 = %d \n" , inte1);
                if ( inte1 == 0x03 )
                  {
                    rwflag = 1;
                    MCP2515_Write(TEC, 0x00);
                    MCP2515_Write(REC, 0x00);
                    MCP2515_Write(EFLG, 0x00);
                    MCP2515_Write(CANINTF, 0x00);
                    rwflag = 0;
                    break;
                  }
                else
                  {
                    rwflag = 1;
                    MCP2515_Reset();
                    Delay (150);
                  }  
              }
            else
              {
                rwflag = 1;
                MCP2515_Reset();
                Delay (150);
              }
           }

        while(1)
          {
            config2 = 0;
            rwflag = 2;
            MCP2515_WriteBits(CANINTF, 0x03 , 0x03);
            config2 = MCP2515_Read(MCP2515REG_CANSTAT);
            if ( (config2 & 0xe0) == 0x80 )
              {
	        Init2_MCP2515(BandRate_250kbps);
                Delay (50);
                rwflag = 2;
                inte2 = MCP2515_Read (CANINTE);
                printk ("inte2 = %d \n" , inte2);
                if ( inte2 == 0x03 )
                  {
                    rwflag = 2;
                    MCP2515_Write(TEC, 0x00);
                    MCP2515_Write(REC, 0x00);
                    MCP2515_Write(EFLG, 0x00);
                    MCP2515_Write(CANINTF, 0x00);
                    rwflag = 0;
                    break;
                  }
                else
                  {
                    rwflag = 2;
                    MCP2515_Reset();
                    Delay (300);
                  }
               
              }
            else
              {
                rwflag = 2;
                MCP2515_Reset();
                Delay (300);
              }
           }

        /*while(1)
          {
            config3 = 0;
            rwflag = 3;
            MCP2515_WriteBits(CANINTF, 0x03 , 0x03);
            config3 = MCP2515_Read(MCP2515REG_CANSTAT);
            if ( (config3 & 0xe0) == 0x80 )
              {
	        Init1_MCP2515(BandRate_250kbps);
                Delay (50);
                rwflag = 3;
                inte3 = MCP2515_Read (CANINTE);
                printk ("inte3 = %d \n" , inte3);
                if ( inte3  == 0x03 )
                  {
                    rwflag = 3;
                    MCP2515_Write(TEC, 0x00);
                    MCP2515_Write(REC, 0x00);
                    MCP2515_Write(EFLG, 0x00);
                    MCP2515_Write(CANINTF, 0x00);
                    rwflag = 0;
                    break;
                  }
                else
                  {
                    rwflag = 3;
                    MCP2515_Reset();
                    Delay (300);
                  }
                
              }
            else
              {
                rwflag = 3;
                MCP2515_Reset();
                Delay (300);
              }
           }*/

	local_irq_restore(flags);  //打开中断,并恢复状态
    
        ret=register_chrdev (CAN_MAJOR,DEVICE_NAME,&s3c2410can_fops);
	if (ret<0)
		{
			return ret;
		}
	
        /*开启2515中断*/
        
    
        set_external_irq(IRQ_EINT18,EXT_FALLING_EDGE, GPIO_PULLUP_DIS);
	set_external_irq(IRQ_EINT2,EXT_FALLING_EDGE, GPIO_PULLUP_DIS);
        set_external_irq(IRQ_EINT11,EXT_FALLING_EDGE, GPIO_PULLUP_DIS);

        enable_irq(IRQ_EINT18);
        enable_irq(IRQ_EINT2);
        enable_irq(IRQ_EINT11);

        ret = request_irq(IRQ_EINT18, can1_irq_isr, SA_INTERRUPT, DEVICE_NAME, NULL);
	if (ret) 
        return ret;
	
	ret = request_irq(IRQ_EINT2, can2_irq_isr, SA_INTERRUPT, DEVICE_NAME, NULL);
	if (ret)
        return ret;

        ret = request_irq(IRQ_EINT11, can3_irq_isr, SA_INTERRUPT, DEVICE_NAME, NULL);
	if (ret)
        return ret;

	devfs_can = devfs_register(NULL,"can",DEVFS_FL_DEFAULT,CAN_MAJOR,                              0, S_IFCHR |S_IRUSR |S_IWUSR |S_IRGRP |S_IWGRP,                                 &s3c2410can_fops, NULL);
  
        EXTINT0 &= 0xfffff0ff;
        EXTINT0 |= 0x00000200;  //设置为下降沿触发
        EXTINT1 &= 0xffff0fff;
        EXTINT1 |= 0x00002000;	
        EXTINT2 &= 0xfffff8ff;
        EXTINT2 |= 0x00000200;
	
        //msk = INTMSK;
	return 0;

}

static void __exit can_exit(void)
{

	devfs_unregister(devfs_can);

}

module_init(can_init);
module_exit(can_exit);