sjacan.c

linux下一个CAN口的驱动和测试程序

#include <linux/unistd.h>
#include <linux/module.h>

#if defined(CONFIG_SMP)
#define __SMP__
#endif

#if defined(CONFIG_MODVERSIONS)
#define MODVERSIONS
#endif

#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/malloc.h>
#include <linux/ioport.h>
#include <linux/mm.h>
#include <linux/interrupt.h>
#include <linux/tqueue.h>
#include <linux/timer.h>
#include <linux/delay.h>
#include <linux/types.h>

#include <asm/io.h>
#include <asm/segment.h>
#include <asm/irq.h>
#include <asm/signal.h>
#include <asm/siginfo.h>
#include <asm/uaccess.h>
#include <asm/fcntl.h>
#include <asm/cache.h>
#include <asm/atomic.h>

#include <sys/syscall.h>

#include "sjacan.h"

/*****************************变量声明*****************************/
unsigned int SJA_major = SJA_MAJOR;
struct SJA_device *Device[SJA_NUM];
unsigned int SJA_irq[SJA_NUM] = {6,6};//声明中断号
unsigned int SJA_baudrate[SJA_NUM] = {40,40};//声明波特率
static char *SJA_name[SJA_NUM] = {"sjacan0","sjacan1"};//声明注册的设备的名称

/*****************************函数声明*****************************/
void SJA_interrupt(int ,void *,struct pt_regs *);
void recv_bottom_half(void *);
void timer_function(unsigned long);

/*****************************SJA device initialize*************************/
static int SJA_init(void)
{
   int res,i;

   res = check_region(SJA_CMD_PORT,3);
   if(res < 0)
        {
       printk(KERN_ALERT"check SJA port failed.\n");
       return res;
        }
    request_region(SJA_CMD_PORT,3,"SJACAN");

    for(i=0;i<SJA_NUM;i++)
          {
       Device[i] = kmalloc(sizeof(struct SJA_device),GFP_KERNEL);
       if(Device[i] == NULL) 
                 {
          printk(KERN_ALERT"allocate device memory failed.\n");
          return(-ENOMEM);
                 }
       memset(Device[i],0,sizeof(struct SJA_device));

       Device[i]->RecvBuf = (unsigned char *)get_free_page(GFP_KERNEL);
       if(Device[i]->RecvBuf == NULL) 
                  {
          printk(KERN_ALERT"allocate Recv memory failed.\n");
          return(-ENOMEM);
                   }
        memset(Device[i]->RecvBuf,0,BUFSIZ);
        Device[i]->RecvHead = 0;
        Device[i]->RecvTail = 0;
        Device[i]->RecvNum = 0;
        Device[i]->RecvQueue = NULL;

        Device[i]->SendBuf = (unsigned char *)get_free_page(GFP_KERNEL);
        if(Device[i]->SendBuf == NULL)
                    {
           printk(KERN_ALERT"allocate Send memory failed.\n");
           return(-ENOMEM);
                      }
         memset(Device[i]->SendBuf,0,BUFSIZ);

         Device[i]->recv_bottom_task = (struct tq_struct *)kmalloc(sizeof(struct tq_struct),GFP_KERNEL);//初始化任务队列结构
         if(Device[i]->recv_bottom_task == NULL) 
                       {
            printk(KERN_ALERT"allocate bottom memory failed.\n");
            return(-ENOMEM);
                         }
          memset(Device[i]->recv_bottom_task,0,sizeof(struct tq_struct));
          Device[i]->recv_bottom_task->routine = recv_bottom_half;
          /*recv_bottom_task->routine指向调用的函数 */
          Device[i]->recv_bottom_task->data = (void *)Device[i];
/*                         recv_bottom_task->data指向传递的参数 */

          Device[i]->timer = (struct timer_list *)kmalloc(sizeof(struct timer_list),GFP_KERNEL);
/*           初始化timer_list结构 */
          if(Device[i]->timer == NULL) 
                         {
             printk(KERN_ALERT"allocate timer memory failed.\n");
             return(-ENOMEM);
                           }
           Device[i]->timer->data = 0;
           Device[i]->timer->function = timer_function;
           Device[i]->timer->expires = 0;
           Device[i]->TimerCount = 0;
           init_timer(Device[i]->timer);

           Device[i]->PortNum = i;
           Device[i]->FrameMode = 1;
           Device[i]->IrqNum = SJA_irq[i];
           Device[i]->BaudRate = SJA_baudrate[i];
                            }
   return 0;
}

/*****************************Function bottom interrupt********************/
void recv_bottom_half(void *device)
{
}

/*****************************Function interrupt****************************/
void SJA_interrupt(int irq,void *dev_id,struct pt_regs *regs)
{
}

/*****************************打开SJACAN**********************************/
int SJA_open(struct inode *inode,struct file *filp)
{
   int res;
   int PortNum;
   struct SJA_device *dev;

   PortNum = MINOR(inode->i_rdev);
   if(PortNum > SJA_NUM) return(-ENODEV);
   dev = Device[PortNum];

   if((filp->f_flags & O_ACCMODE) == O_WRONLY)
       {} 
   else 
       {
     if(dev->ref_count == 0) 
             {
        res = request_irq(dev->IrqNum, SJA_interrupt,SA_SHIRQ | SA_INTERRUPT,SJA_name[dev->PortNum],dev);
        if(res < 0) 
                     {
           printk(KERN_ALERT"can't request irq %i.\n",dev->IrqNum);
           return res;
                       }
         printk(KERN_ALERT"request irq %i success.\n",dev->IrqNum);

                       /*************************初始化 SJACAN，写入一些配置参数************************/
         if(dev->FrameMode)
         SJA_WRITE(0x01,SJA_MODE,(SJA1_DAT_PORT+PortNum));
         SJA_WRITE(0x00,SJA_MODE,(SJA1_DAT_PORT+PortNum));
                
         SJA_WRITE(0x01,SJA_ACR0,(SJA1_DAT_PORT+PortNum));
         SJA_WRITE(0xff,SJA_ACR1,(SJA1_DAT_PORT+PortNum));
         SJA_WRITE(0x02,SJA_ACR2,(SJA1_DAT_PORT+PortNum));
         SJA_WRITE(0xff,SJA_ACR3,(SJA1_DAT_PORT+PortNum));
         SJA_WRITE(0xff,SJA_AMR0,(SJA1_DAT_PORT+PortNum));
         SJA_WRITE(0xff,SJA_AMR1,(SJA1_DAT_PORT+PortNum));
         SJA_WRITE(0xff,SJA_AMR2,(SJA1_DAT_PORT+PortNum));
         SJA_WRITE(0xff,SJA_AMR3,(SJA1_DAT_PORT+PortNum));
         SJA_WRITE(0x07,SJA_BTR0,(SJA1_DAT_PORT+PortNum));
         SJA_WRITE(0xff,SJA_BTR1,(SJA1_DAT_PORT+PortNum));/*设置波特率为40k*/
         SJA_WRITE(0x1a,SJA_OCR,(SJA1_DAT_PORT+PortNum));
         SJA_WRITE(0x01,SJA_IE,(SJA1_DAT_PORT+PortNum));
         SJA_WRITE(0x00,SJA_MODE,(SJA1_DAT_PORT+PortNum));
              }
      dev->ref_count++;
        }

   filp->private_data = dev;
    /*MOD_INC_USE_COUNT; */
   return 0;
}

/*****************************Functin SJA_release**************************/
int SJA_release(struct inode *inode,struct file *filp)
{
   struct SJA_device *dev = filp->private_data;

   if((filp->f_flags & O_ACCMODE) != O_WRONLY) 
        {
      if(--dev->ref_count == 0)
                {
          free_irq(dev->IrqNum,dev);
          SJA_WRITE(0x00,SJA_IE,(SJA1_DAT_PORT+dev->PortNum));
                }
        }
/*         MOD_DEC_USE_COUNT; */
   return 0;
}

/*****************************Function timer*******************************/
void timer_function(unsigned long ptr)
{
}

/*****************************File operations define************************/
struct file_operations SJA_fops = {
    NULL,     
    NULL,    //read
    NULL,    //write
    NULL,      
    NULL,    //EMM_poll,
    NULL,    //ioctl
    NULL,       
    SJA_open,    //open
    NULL,
    SJA_release,    //release
    NULL,        
    NULL,
    NULL,
    NULL,
    NULL     
};

/****************************Module initialize******************************/
int init_module(void)
{
   int res;

   EXPORT_NO_SYMBOLS;
   res = register_chrdev(SJA_major,"SJACAN",&SJA_fops);
   if(res < 0) 
        {
      printk(KERN_ALERT"device register failed.\n");
      return res;
        }
   if(SJA_major == 0) SJA_major = res;

   if(SJA_init() < 0) printk(KERN_ALERT"SJA device initializition failed.\n");
   else printk(KERN_ALERT"SJACAN initializition success.\n");
   return 0;
}

/****************************Module release********************************/
void cleanup_module(void)
{
   unregister_chrdev(SJA_major,"SJACAN");
   release_region(SJA_CMD_PORT,3);
   printk(KERN_ALERT"SJACAN release success.\n");
}