《Linux设备驱动开发详解》源码——second

/home/lihacker/develop/svn/ldd6410-read-only/training/kernel/drivers/second

< second.c >

#include <linux/module.h>

#include <linux/types.h>

#include <linux/fs.h>

#include <linux/errno.h>

#include <linux/mm.h>

#include <linux/sched.h>

#include <linux/init.h>

#include <linux/cdev.h>

#include <asm/io.h>

#include <asm/system.h>

#include <asm/uaccess.h>



#define SECOND_MAJOR 248    /*Ô€ÉèµÄsecondµÄÖ÷É豞ºÅ*/                       

                                                                             

static int second_major = SECOND_MAJOR;                                      

                                                                             

/*secondÉ豞œá¹¹Ìå*/                                                         

struct second_dev {                                                          

  struct cdev cdev; /*cdevœá¹¹Ìå*/                                           

  atomic_t counter;/* Ò»¹²Ÿ­ÀúÁ˶àÉÙÃ룿*/                                   

  struct timer_list s_timer; /*É豞ҪʹÓõĶšÊ±Æ÷*/                          

};                                                                           

                                                                             

struct second_dev *second_devp; /*É豞œá¹¹ÌåÖžÕë*/                           

                                                                             

/*¶šÊ±Æ÷ŽŠÀíº¯Êý*/                                                           

static void second_timer_handle(unsigned long arg)                           

{                                                                            

  mod_timer(&second_devp->s_timer,jiffies + HZ);                             

  atomic_inc(&second_devp->counter);                                         

                                                                             

  printk(KERN_NOTICE "current jiffies is %ld\n", jiffies);                   

}                                                                            

                                                                             

/*ÎÄŒþŽò¿ªº¯Êý*/                                                             

int second_open(struct inode *inode, struct file *filp)                      

{                                                                            

  /*³õÊŒ»¯¶šÊ±Æ÷*/                                                           

  init_timer(&second_devp->s_timer);                                         

  second_devp->s_timer.function = &second_timer_handle;                      

  second_devp->s_timer.expires = jiffies + HZ;                               

                                                                             

  add_timer(&second_devp->s_timer); /*ÌíŒÓ£š×¢²á£©¶šÊ±Æ÷*/                   

                                                                             

  atomic_set(&second_devp->counter,0); //ŒÆÊýÇå0                             

                                                                             

  return 0;                                                                  

}                                                                            

/*ÎÄŒþÊͷź¯Êý*/                                                             

int second_release(struct inode *inode, struct file *filp)                   

{                                                                            

  del_timer(&second_devp->s_timer);                                          

                                                                             

  return 0;                                                                  

}                                                                            

                                                                             

/*¶Áº¯Êý*/                                                                   

static ssize_t second_read(struct file *filp, char __user *buf, size_t count,

  loff_t *ppos)                                                              

{                                                                            

  int counter;                                                               

                                                                             

  counter = atomic_read(&second_devp->counter);                              

  if(put_user(counter, (int*)buf))                                           

  	return - EFAULT;                                                         

  else                                                                       

  	return sizeof(unsigned int);                                             

}                                                                            

                                                                             

/*ÎÄŒþ²Ù×÷œá¹¹Ìå*/                                                           

static const struct file_operations second_fops = {                          

  .owner = THIS_MODULE,                                                      

  .open = second_open,                                                       

  .release = second_release,                                                 

  .read = second_read,                                                       

};                                                                           

                                                                             

/*³õÊŒ»¯²¢×¢²ácdev*/                                                         

static void second_setup_cdev(struct second_dev *dev, int index)             

{                                                                            

  int err, devno = MKDEV(second_major, index);                               

                                                                             

  cdev_init(&dev->cdev, &second_fops);                                       

  dev->cdev.owner = THIS_MODULE;                                             

  err = cdev_add(&dev->cdev, devno, 1);                                      

  if (err)                                                                   

    printk(KERN_NOTICE "Error %d adding LED%d", err, index);                 

}                                                                            

                                                                             

/*É豞Çý¶¯Ä£¿éŒÓÔغ¯Êý*/                                                     

int second_init(void)                                                        

{                                                                            

  int ret;                                                                   

  dev_t devno = MKDEV(second_major, 0);                                      

                                                                             

  /* ÉêÇëÉ豞ºÅ*/                                                            

  if (second_major)                                                          

    ret = register_chrdev_region(devno, 1, "second");                        

  else { /* ¶¯Ì¬ÉêÇëÉ豞ºÅ */                                                

    ret = alloc_chrdev_region(&devno, 0, 1, "second");                       

    second_major = MAJOR(devno);                                             

  }                                                                          

  if (ret < 0)                                                               

    return ret;                                                              

  /* ¶¯Ì¬ÉêÇëÉ豞œá¹¹ÌåµÄÄÚŽæ*/                                              

  second_devp = kmalloc(sizeof(struct second_dev), GFP_KERNEL);              

  if (!second_devp) {   /*ÉêÇëʧ°Ü*/                                         

    ret =  - ENOMEM;                                                         

    goto fail_malloc;                                                        

  }                                                                          



  memset(second_devp, 0, sizeof(struct second_dev));                         



  second_setup_cdev(second_devp, 0);                                         



  return 0;                                                                  



fail_malloc:

  unregister_chrdev_region(devno, 1);

  return ret;                           

}                                                                            



/*Ä£¿éжÔغ¯Êý*/                                                             

void second_exit(void)                                                       

{                                                                            

  cdev_del(&second_devp->cdev);   /*×¢Ïúcdev*/                               

  kfree(second_devp);     /*ÊÍ·ÅÉ豞œá¹¹ÌåÄÚŽæ*/                             

  unregister_chrdev_region(MKDEV(second_major, 0), 1); /*ÊÍ·ÅÉ豞ºÅ*/        

}                                                                            

                                                                             

MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");                             

MODULE_LICENSE("Dual BSD/GPL");                                              

                                                                             

module_param(second_major, int, S_IRUGO);                                    

                                                                             

module_init(second_init);                                                    

module_exit(second_exit);                                                    

< Makefile >

KVERS = $(shell uname -r)

# Kernel modules
obj-m += second.o

# Specify flags for the module compilation.
#EXTRA_CFLAGS=-g -O0

build: kernel_modules user_test

kernel_modules:
	make -C /lib/modules/$(KVERS)/build M=$(CURDIR) modules
user_test:
	gcc -o second_test second_test.c

clean:
	make -C /lib/modules/$(KVERS)/build M=$(CURDIR) clean

< second_test.c >

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <fcntl.h>

#include <signal.h>

#include <sys/stat.h>



main()

{

  int fd;

  int counter = 0;

  int old_counter = 0;

  

  /*Žò¿ª/dev/secondÉ豞ÎÄŒþ*/

  fd = open("/dev/second", O_RDONLY);

  if (fd != - 1) {

    while (1) {

      read(fd,&counter, sizeof(unsigned int));/* ¶ÁÄ¿Ç°Ÿ­ÀúµÄÃëÊý */

      if(counter!=old_counter) {	

      	printf("seconds after open /dev/second :%d\n",counter);

      	old_counter = counter;

      }	

    }    

  } else {

    printf("Device open failure\n");

  }

}