【驱动】Linux初级驱动系列框架

set serverip 192.168.7.xx
set ipaddr 192.168.7.xxx
set bootcmd tftp 20800000 zImage\;bootm 20800000    //开发模式
set bootcmd nand read 20800000 40000 2000000\;bootm 20800000 //产品模式
set bootargs root=/dev/nfs nfsroot=192.168.7.xx:/opt/rootfs console=ttySAC0,115200 ip=192.168.7.xxx

 sudo vi /etc/export
 sudo /etc/init.d/nfs-kerner-server restart
 sudo exportfs -a

//驱动人员必须自己构建一个变量
struct file_operations    --->表示设备的操作方法
{
 struct module *owner;
 ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
 ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
 int (*open) (struct inode *, struct file *);
 ...
};
 

//老的方法:不需要驱动人员构建,只要调用register_chrdev
//新的方法:需要驱动人员构建
struct cdev   ---->表示一个字符设备
{
 const struct file_operations *ops;//设备的操作方法
 dev_t dev;        //设备号
 ...
};
 

//1.mknod /dev/xxx c major minor
//2.class_create  device_create
struct inode  ---->表示一个设备节点:每个目录或者每个文件都对应一个inode结构体(静态的)
{ 
 dev_t   i_rdev;     //设备号
 const struct file_operations *i_fop; /* former ->i_op->default_file_ops  def_chr_fops */
 struct cdev  *i_cdev;
 ...
};
 

struct file   --->表示一个打开的文件:每一个文件被打开一次,都会创建一个file结构体(动态的)
{
 loff_t    f_pos;     //文件的偏移量
 unsigned int   f_flags;    //标号    open("/dev/xxx",O_RDWR|O_NONBLOCK)  file->f_flags |=O_RDWR|O_NONBLOCK
 const struct file_operations *f_op;  //文件的操作方法
 void   *private_data;
 ...
};

老的方法:register_chrdev(major,name,file_Operations); ----->unregister_chrdev
新的方法:register_chrdev_region(dev_t,count,name);  ----->unregister_chrdev_region
         alloc_chrdev_region(dev_t *,baseminor,count,name);

cdev_alloc
cdev_init(struct cdev*, file_operations);
cdev_add
cdev_del

手动创建:mknod /dev/xxx c major minor
动态创建:class_create(owner,name);
       　device_create

MKDEV(major,minor)
MAJRO(dev_t)
MINOR(dev_t)
iminor(struct inode);
imajor(struct inode);

copy_from_user
copy_to_user

/*param1:中断号  mach/irqs.h
 *param2:中断服务程序  typedef irqreturn_t (*irq_handler_t)(int, void *);   linux/irqreturn.h
 *   enum irqreturn {
 *   IRQ_NONE,   //如果中断处理失败则返回 0
 *   IRQ_HANDLED,     //如果中断处理成功则返回 1
 *   IRQ_WAKE_THREAD,
 *  };
 *
 *  typedef enum irqreturn irqreturn_t;
 *param2:中断触发方式  linux/interrupt.h
 *param3:名字
 *param4:id号,一般共享中断才会用,
 */
ret = request_irq(IRQ_EINT(1), irq_handler_t handler, unsigned long flags, const char * name, void * dev)

free_irq(unsigned int irq, void * dev_id)

typedef irqreturn_t (*irq_handler_t)(int, void *);

struct __wait_queue_head {
 spinlock_t lock; /*锁,用来同步*/
 struct list_head task_list;/*链表*/
};
typedef struct __wait_queue_head wait_queue_head_t;

struct __wait_queue {
 unsigned int flags;
#define WQ_FLAG_EXCLUSIVE 0x01
 void *private;    /*应该指向当前进程*/
 wait_queue_func_t func;  /*唤醒函数*/
 struct list_head task_list;/*任务链表*/
};
typedef struct __wait_queue wait_queue_t;

/*定义一个节点,并初始化任务节点*/
#define __WAITQUEUE_INITIALIZER(name, tsk) {    \
 .private = tsk,       .func  = default_wake_function,    .task_list = { NULL, NULL } }
#define DECLARE_WAITQUEUE(name, tsk)     \
 wait_queue_t name = __WAITQUEUE_INITIALIZER(name, tsk)

:/*定义并初始化一个任务节点*/
#define DEFINE_WAIT_FUNC(name, function)    \
 wait_queue_t name = {        .private = current,      .func  = function,      .task_list = LIST_HEAD_INIT((name).task_list),  }
#define DEFINE_WAIT(name) DEFINE_WAIT_FUNC(name, autoremove_wake_function)

/*初始化等待队列头*/
#define __WAIT_QUEUE_HEAD_INITIALIZER(name) {    \
 .lock  = __SPIN_LOCK_UNLOCKED(name.lock),   .task_list = { &(name).task_list, &(name).task_list } }
/*定义等待队列头,并且初始化等待队列头*/
#define DECLARE_WAIT_QUEUE_HEAD(name) \
 wait_queue_head_t name = __WAIT_QUEUE_HEAD_INITIALIZER(name)

/*定义等待队列头*/
wait_queue_head_t *q;
/*初始化等待队列头*/
#define init_waitqueue_head(q)     do {        static struct lock_class_key __key;          __init_waitqueue_head((q), &__key);  } while (0)

void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait);

vfs:long sys_poll(struct pollfd __user *ufds, //系统调用号168
                  unsigned int nfds,long timeout_msecs)
  
  /*1.转换时间,转换为以jiffies(内核时间片)为单位的时间*/
  
  do_sys_poll(ufds, nfds, &timeout_jiffies);
   
   poll_initwait(&table);
   /*3.查询是否有事件*/
   do_poll(nfds, head, &table, timeout);
    for (;;) {
         /*3.1 改变进程状态*/
         set_current_state(TASK_INTERRUPTIBLE);   //可被信号中断的休眠
         /*3.2 将进程挂入等待队列*/
         if (do_pollfd(pfd, pt)) {
            if (file->f_op && file->f_op->poll)          //在此调用驱动程序的poll函数
             mask = file->f_op->poll(file, pwait);
             return mask;
          count++;
          pt = NULL;
         }
         /*3.3 1)count>0 2)时间用完 3)有信号*/
         if (count || !*timeout || signal_pending(current))
          break;
         /*3.4 时间减少*/
         *timeout -= __timeout;
         /*3.5 调度,休眠(定时休眠)*/
         schedule_timeout(__timeout);  
    }
    __set_current_state(TASK_RUNNING);

cp  hello.c /home/farsight/work/linux_source/linux-2.6.35.5/drivers/char/

obj-$(CONFIG_HELLO)             += hello.o   //在其中添加如下项

config N_GSM  //菜单项
 tristate "GSM MUX line discipline support (EXPERIMENTAL)"   //菜单项目名字 tristate-属性,表示三态<> y-编译到内核镜像 n-不编译 m-编译成模块
    depends on EXPERIMENTAL     //依赖
    depends on NET
    help      //帮助文档
         This line discipline provides support for the GSM MUX protocol and
         presents the mux as a set of 61 individual tty devices.

config RIO_OLDPCI
          bool "Support really old RIO/PCI cards"
          depends on RIO
          help
            Older RIO PCI cards need some initialization-time configuration t     o
            determine the IRQ and some control addresses.  If you have a RIO      and
           this doesn‘t seem to work, try setting this to Y.

config HVC_CONSOLE
          bool "pSeries Hypervisor Virtual Console support"
          depends on PPC_PSERIES
          select HVC_DRIVER    //帮你选择
          select HVC_IRQ
          help
            pSeries machines when partitioned support a hypervisor virtual
            console. This driver allows each pSeries partition to have a cons     ole
            which is accessed via the HMC.

config LEGACY_PTYS
          bool "Legacy (BSD) PTY support"
          default y      //默认选上了
          ---help---
            A pseudo terminal (PTY) is a software device consisting of two
            halves: a master and a slave. The slave device behaves identical      to
            a physical terminal; the master device is used by a process to

config HELLO
         tristate "farsight hello module"
         ---help---
            this is a simple hello module by liucw

make menuconfig