如何编写驱动程序？

代码：

#include&ltlinux/module.h&gt

#include&ltlinux/kernel.h&gt

#include&ltasm/io.h&gt

#include&ltlinux/miscdevice.h&gt

#include&ltlinux/fs.h&gt

#include&ltasm/uaccess.h&gt

//流水灯代码

#define GPM4CON 0x110002e0

#define GPM4DAT 0x110002e4

static unsigned long*ledcon=NULL

static unsigned long*leddat=NULL

//自定义write文件 *** 作(不自定义的话，内核有默认的一套文件 *** 作函数)

static ssize_t test_write(struct file*filp,const char __user*buff,size_t count,loff_t*offset)

{

int value=0

int ret=0

ret=copy_from_user(&value,buff,4)

//底层驱动只定义基本 *** 作动作，不定义功能

if(value==1)

{

*leddat|=0x0f

*leddat&=0xfe

}

if(value==2)

{

*leddat|=0x0f

*leddat&=0xfd

}

if(value==3)

{

*leddat|=0x0f

*leddat&=0xfb

}

if(value==4)

{

*leddat|=0x0f

*leddat&=0xf7

}

return 0

}

//文件 *** 作结构体初始化

static struct file_operations g_tfops={

.owner=THIS_MODULE,

.write=test_write,

}

//杂设备信息结构体初始化

static struct miscdevice g_tmisc={

.minor=MISC_DYNAMIC_MINOR,

.name="test_led",

.fops=&g_tfops,

}

//驱动入口函数杂设备初始化

static int __init test_misc_init(void)

{

//IO地址空间映射到内核的虚拟地址空间

ledcon=ioremap(GPM4CON,4)

leddat=ioremap(GPM4DAT,4)

//初始化led

*ledcon&=0xffff0000

*ledcon|=0x00001111

*leddat|=0x0f

//杂设备注册函数

misc_register(&g_tmisc)

return 0

}

//驱动出口函数

static void __exit test_misc_exit(void)

{

//释放地址映射

iounmap(ledcon)

iounmap(leddat)

}

//指定模块的出入口函数

module_init(test_misc_init)

module_exit(test_misc_exit)

MODULE_LICENSE("GPL")

扩展资料：

include用法：

#include命令预处理命令的一种，预处理命令可以将别的源代码内容插入到所指定的位置；可以标识出只有在特定条件下才会被编译的某一段程序代码；可以定义类似标识符功能的宏，在编译时，预处理器会用别的文本取代该宏。

插入头文件的内容

#include命令告诉预处理器将指定头文件的内容插入到预处理器命令的相应位置。有两种方式可以指定插入头文件：

1、#include&lt文件名&gt

2、#include"文件名"

如果需要包含标准库头文件或者实现版本所提供的头文件，应该使用第一种格式。如下例所示：

#include&ltmath.h&gt//一些数学函数的原型，以及相关的类型和宏

如果需要包含针对程序所开发的源文件，则应该使用第二种格式。

采用#include命令所插入的文件，通常文件扩展名是.h，文件包括函数原型、宏定义和类型定义。只要使用#include命令，这些定义就可被任何源文件使用。如下例所示：

#include"myproject.h"//用在当前项目中的函数原型、类型定义和宏

你可以在#include命令中使用宏。如果使用宏，该宏的取代结果必须确保生成正确的#include命令。例1展示了这样的#include命令。

【例1】在#include命令中的宏

#ifdef _DEBUG_

#define MY_HEADER"myProject_dbg.h"

#else

#define MY_HEADER"myProject.h"

#endif

#include MY_HEADER

当上述程序代码进入预处理时，如果_DEBUG_宏已被定义，那么预处理器会插入myProject_dbg.h的内容；如果还没定义，则插入myProject.h的内容。

实现方法和步骤如下：

1、如果网络设备（包括wireless）是PCI规范的，则先是向内核注册该PCI设备(pci_register_driver)，然后由pci_driver数据结构中的probe函数指针所指向的侦测函数来初始化该PCI设备，并且同时注册和初始化该网络设备。

申明为PCI设备：

static struct pci_driver tg3_driver = {   

    .name = DRV_MODULE_NAME,   

    .id_table = tg3_pci_tbl, //此驱动所支持的网卡系列，vendor_id, device_id   

    .probe = tg3_init_one, //初始化网络设备的回调函数   

    .remove = __devexit_p(tg3_remove_one), //注销网络设备的回调函数   

    .suspend = tg3_suspend, //设备挂起函数   

    .resume = tg3_resume //设备恢复函数   

}

PCI设备探测函数probe，初始化网络设备：

static int __devinit tg3_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)   

{   

       

    //初始化设备，使I/O，memory可用，唤醒设备   

    pci_enable_device(pdev)   

       

    //申请内存空间，配置网卡的I/O，memory资源   

    pci_request_regions(pdev, DRV_MODULE_NAME)   

    pci_set_master(pdev)   

       

    //设置DMA属性   

    pci_set_dma_mask(pdev, (u64) 0xffffffffffffffff)   

       

    //网卡 I/O,memory资源的启始地址   

    tg3reg_base = pci_resource_start(pdev, 0)   

       

    //网卡I/O,memory资源的大小   

    tg3reg_len = pci_resource_len(pdev, 0)   

       

    //分配并设置网络设备   

    dev = alloc_etherdev(sizeof(*tp))   

       

    //申明为内核设备模块   

    SET_MODULE_OWNER(dev)   

       

    //初始化私有结构中的各成员值   

    tp = dev->priv   

    tp->pdev = pdev   

    tp->dev = dev   

    ??   

    //锁的初始化   

    spin_lock_init(&tp->lock)   

       

    //映射I/O,memory地址到私有域中的寄存器结构   

    tp->regs = (unsigned long) ioremap(tg3reg_base, tg3reg_len)   

    dev->irq = pdev->irq   

       

    //网络设备回调函数赋值   

    dev->open = tg3_open   

    dev->stop = tg3_close   

    dev->get_stats = tg3_get_stats   

    dev->set_multicast_list = tg3_set_rx_mode   

    dev->set_mac_address = tg3_set_mac_addr   

    dev->do_ioctl = tg3_ioctl   

    dev->tx_timeout = tg3_tx_timeout   

    dev->hard_start_xmit= tg3_start_xmit   

       

    //网卡的MAC地址赋值dev->addr   

    tg3_get_device_address(tp)   

       

    //注册网络设备   

    register_netdev(dev)   

       

    //把网络设备指针地址放入PCI设备中的设备指针中   

    pci_set_drvdata(pdev, dev)   

}

打开网络设备：

/* int request_irq(unsigned int irq, 

                        void (*handler)(int irq, void *dev_id, struct pt_regs *regs),  

                        unsigned long irqflags, 

                        const char * devname, 

                        void *dev_id) 

irq是要申请的硬件中断号。在Intel平台，范围0--15。 

handler是向系统登记的中断处理函数。 

这是一个回调函数，中断发生时，系统调用这个函数，传入的参数包括硬件中断号，device id，寄存器值。 

dev_id就是下面的request_irq时传递给系统的参数dev_id。 

irqflags是中断处理的一些属性。比较重要的有 SA_INTERRUPT， 

标明中断处理程序是快速处理程序(设置SA_INTERRUPT)还是慢速处理程序(不设置SA_INTERRUPT)。 

快速 处理程序被调用时屏蔽所有中断。慢速处理程序不屏蔽。 

还有一个SA_SHIRQ属性，设置了以后运行多个设备共享中断。dev_id在中断共享时会用到。 

 一般设置为这个设备的device结构本身或者NULL。 

 中断处理程序可以用dev_id找到相应的控制这个中断的设备，或者用rq2dev_map找到 中断对应的设备。 

*/   

  

static int tg3_open(struct net_device *dev)   

{   

    //分配一个中断   

    request_irq(dev->irq, tg3_interrupt, SA_SHIRQ, dev->name, dev)   

       

    //初始化硬件   

    tg3_init_hw(tp)   

       

    //初始化收包和发包的缓冲区   

    tg3_init_rings(tp)   

       

    //初始化定时器   

    init_timer(&tp->timer)   

    tp->timer.expires = jiffies + tp->timer_offset   

    tp->timer.data = (unsigned long) tp   

    tp->timer.function = tg3_timer //超时回调函数   

    add_timer(&tp->timer)   

       

    //允许网卡开始传输包   

    netif_start_queue(dev)   

}

---