linux字符设备驱动

Ⅰ 在虚拟机linux操作系统上怎么编写一个简单的字符设备驱动程序

下载 virtualbox 下载一个 linux iso
用virtualbox 建立虚拟系统 配置好 加载iso 启动安装
VMware安装完毕后，利用它可以建立多个虚拟机，每新建一个虚拟机，就会要求你建立一个配置文件。这个配置文件实际上相当于新电脑的“硬件配置”，你可以在配置文件中决定虚拟机的硬盘如何配置，内存多大．准备运行哪种操作系统，是否有网络等。配置Linux虚拟机的步骤如下。

(1)选择File菜单下的“New Virtual Machine”出现新虚拟机向导后单击“下一步”，选择“Typical”典型安装。

(2)再单击“下一步”，在选择操作系统界面的“Guest Operation System”中选择 “Linux”，然后单击Version对应的下拉菜单选择具体的Linux版本， 此处我们选择“Red Hat LinuX”。

(3)单击“下一步”进入安装目录选择界面。该界面上面的文本框是系统的名字，保持默认值即可，下面的文本框需要选择虚拟机操作系统的安装位置。

(4)根据需要选择好后，单击“下一步”按钮，出现设置虚拟机内存大小的界面。Linux9．O对内存的要求是：文本模式至少需要64MB；图形化模式至少需要128MB，推荐使用192MB。此处我们选择192MB：

(5)单击“下一步”按钮进入网络连接方式选择界面。VMware有四种网络设置方式，一般来说，Bridged方式使虚拟机就像网络内一台独立的计算机一样，最为方便好用(四种连网方式的区别大家可参考VMware的有关资料)。在此、我们选择Brided方式。

(6)单击“下一步”按钮进入虚拟磁盘的设置界面。 这里有三种方式(Create a new virtual disk、Use an existing virtual disk、Use a physical disk)可供选择、建议初学者选择“Create a new Virtual disk”，其含义是新建一个虚拟磁盘，该虚拟磁盘只是主机—卜的一个独立文件。

(7)在“下一步”中设置磁盘大小。在此、我们采用默认的4GB。

(8)单击“下一步”进入文件存放路径选择界面。

在此界面可单击Browse按钮进行设置。此处我们使用默认值，单击“完成”按钮。

至此，完成一个虚拟机的配置。

Ⅱ 请问Linux驱动程序中，字符设备驱动，块设备驱动以及网络驱动的区别和比较，学的时候需要注意些什么

可以讲字符设备和块设备归为一类，它们都是可以顺序/随机地进行读取和存储的单元，二者驱动主要在于块设备需要具体的burst实现，对访问也有一定的边界要求。其他的没有什么不同。
网络设备是特殊设备的驱动，它负责接收和发送帧数据，可能是物理帧，也可能是ip数据包，这些特性都有网络驱动决定。它并不存在于/dev下面，所以与一般的设备不同。网络设备是一个net_device结构，并通过register_netdev注册到系统里，最后通过ifconfig -a的命令就能看到。
不论是什么设备，设备级的数据传输都是基本类似的，内核里的数据表示只是一部分，更重要的是总线的访问，例如串行spi，i2c，并行dma等。

Ⅲ 在Linux内核中,注册字符设备驱动程序的函数是

字符设备驱动程序框架 1、写出open、write函数 2、告诉内核 1）、定义一个struct file_operations结构并填充好 static struct file_operations first_drv_fops = { .owner = THIS_MODULE, /* 这是一个宏，推向编译模块时自动创建的__this_mole变量 */ .open = first_drv_open, .write = first_drv_write, }; 2）、把struct file_operations结构体告诉内核 major = register_chrdev(0, "first_drv", &first_drv_fops); // 注册, 告诉内核相关参数：第一个，设备号，0自动分配主设备号，否则为主设备号0－255 第二个：设备名第二个：struct file_operations结构体 4）、register_chrdev由谁调用（入口函数调用） static int first_drv_init(void) 5）、入口函数须使用内核宏来修饰 mole_init(first_drv_init); mole_init会定义一个结构体，这个结构体里面有一个函数指针指向first_drv_init这个函数，当我们加载或安装一个驱动时，内核会自动找到这个结构体，然后调用里面的函数指针，这个函数指针指向first_drv_init这个函数，first_drv_init这个函数就是把struct file_operations结构体告诉内核 6）、有入口函数就有出口函数 mole_exit(first_drv_exit); 最后加上协议 MODULE_LICENSE("GPL"); 3、mdev根据系统信息自动创建设备节点： 每次写驱动都要手动创建设备文件过于麻烦，使用设备管理文件系统则方便很多。在2.6的内核以前一直使用的是devfs，但是它存在许多缺陷。它创建了大量的设备文件，其实这些设备更本不存在。而且设备与设备文件的映射具有不确定性，比如U盘即可能对应sda，又可能对应sdb。没有足够的主/辅设备号。2.6之后的内核引入了sysfs文件系统，它挂载在/sys上，配合udev使用，可以很好的完成devfs的功能，并弥补了那些缺点。（这里说一下，当今内核已经使用netlink了）。 udev是用户空间的一个应用程序，在嵌入式中用的是mdev，mdev在busybox中。mdev是udev的精简版。首先在busybox中添加支持mdev的选项： Linux System Utilities ---> [*] mdev [*] Support /etc/mdev.conf [*] Support subdirs/symlinks [*] Support regular expressions substitutions when renaming device [*] Support command execution at device addition/removal 然后修改/etc/init.d/rcS: echo /sbin/mdev > /proc/sys/kernel/hotplug /sbin/mdev -s 执行mdev -s ：以‘-s’为参数调用位于 /sbin目录写的mdev（其实是个链接，作用是传递参数给/bin目录下的busybox程序并调用它），mdev扫描 /sys/class 和 /sys/block 中所有的类设备目录，如果在目录中含有名为“dev”的文件，且文件中包含的是设备号，则mdev就利用这些信息为这个设备在/dev 下创建设备节点文件。一般只在启动时才执行一次 “mdev -s”。热插拔事件：由于启动时运行了命 令：echo /sbin/mdev > /proc/sys/kernel/hotplug ，那么当有热插拔事件产生时，内核就会调用位于 /sbin目录的mdev。这时mdev通过环境变量中的 ACTION 和 DEVPATH，来确定此次热插拔事件的动作以及影响了/sys中的那个目录。接着会看看这个目录中是否“dev”的属性文件，如果有就利用这些信息为 这个设备在/dev 下创建设备节点文件重新打包文件系统，这样/sys目录，/dev目录就有东西了下面是create_class的原型： #define class_create(owner, name) / ({ / static struct lock_class_key __key; / __class_create(owner, name, &__key); / }) extern struct class * __must_check __class_create(struct mole *owner, const char *name, struct lock_class_key *key); class_destroy的原型如下： extern void class_destroy(struct class *cls); device_create的原型如下： extern struct device *device_create(struct class *cls, struct device *parent, dev_t devt, void *drvdata, const char *fmt, ...) __attribute__((format(printf, 5, 6))); device_destroy的原型如下： extern void device_destroy(struct class *cls, dev_t devt); 具体使用如下，可参考后面的实例： static struct class *firstdrv_class; static struct class_device *firstdrv_class_dev; firstdrv_class = class_create(THIS_MODULE, "firstdrv"); firstdrv_class_dev = class_device_create(firstdrv_class, NULL, MKDEV(major, 0), NULL, "xyz"); /* /dev/xyz */ class_device_unregister(firstdrv_class_dev); class_destroy(firstdrv_class); 下面再来看一下应用程序如何找到这个结构体的在应用程序中我们使用open打开一个设备：如：open(/dev/xxx, O_RDWR); xxx有一个属性，如字符设备为c,后面为读写权限，还有主设备名、次设备名，我们注册时 通过register_chrdev(0, "first_drv", &first_drv_fops)（有主设备号，设备名，struct file_operations结构体）将first_drv_fops结构体注册到内核数组chrdev中去的，结构体中有open,write函数，那么应用程序如何找到它的，事实上是根据打开的这个文件的属性中的设备类型及主设备号在内核数组chrdev里面找到我们注册的first_drv_fops，实例代码： #include #include #include #include #include #include #include #include #include #include static struct class *firstdrv_class; static struct class_device *firstdrv_class_dev; volatile unsigned long *gpfcon = NULL; volatile unsigned long *gpfdat = NULL; static int first_drv_open(struct inode *inode, struct file *file) { //printk("first_drv_open\n"); /* 配置GPF4,5,6为输出 */ *gpfcon &= ~((0x3<<(4*2)) | (0x3<<(5*2)) | (0x3<<(6*2))); *gpfcon |= ((0x1<<(4*2)) | (0x1<<(5*2)) | (0x1<<(6*2))); return 0; } static ssize_t first_drv_write(struct file *file, const char __user *buf, size_t count, loff_t * ppos) { int val; //printk("first_drv_write\n"); _from_user(&val, buf, count); // _to_user(); if (val == 1) { // 点灯 *gpfdat &= ~((1<<4) | (1<<5) | (1<<6)); } else { // 灭灯 *gpfdat |= (1<<4) | (1<<5) | (1<<6); } return 0; } static struct file_operations first_drv_fops = { .owner = THIS_MODULE, /* 这是一个宏，推向编译模块时自动创建的__this_mole变量 */ .open = first_drv_open, .write = first_drv_write, }; int major; static int first_drv_init(void) { major = register_chrdev(0, "first_drv", &first_drv_fops); // 注册, 告诉内核 firstdrv_class = class_create(THIS_MODULE, "firstdrv"); firstdrv_class_dev = class_device_create(firstdrv_class, NULL, MKDEV(major, 0), NULL, "xyz"); /* /dev/xyz */ gpfcon = (volatile unsigned long *)ioremap(0x56000050, 16); gpfdat = gpfcon + 1; return 0; } static void first_drv_exit(void) { unregister_chrdev(major, "first_drv"); // 卸载 class_device_unregister(firstdrv_class_dev); class_destroy(firstdrv_class); iounmap(gpfcon); } mole_init(first_drv_init); mole_exit(first_drv_exit); MODULE_LICENSE("GPL"); 编译用Makefile文件 KERN_DIR = /work/system/linux-2.6.22.6 all: make -C $(KERN_DIR) M=`pwd` moles clean: make -C $(KERN_DIR) M=`pwd` moles clean rm -rf moles.order obj-m += first_drv.o 测试程序： #include #include #include #include /* firstdrvtest on * firstdrvtest off */ int main(int argc, char **argv) { int fd; int val = 1; fd = open("/dev/xyz", O_RDWR); if (fd < 0) { printf("can't open!\n"); } if (argc != 2) { printf("Usage :\n"); printf("%s \n", argv[0]); return 0; } if (strcmp(argv[1], "on") == 0) { val = 1; } else { val = 0; } write(fd, &val, 4); return 0; }

Ⅳ linux的设备驱动一般分为几类各有什么特点

大致分为三类，字符驱动，块设备驱动，网络设备驱动。
字符设备可以看成是用字节流存取的文件

块设备则可以看成是可以任意存取字节数的字符设备，在应用上只是内核管理数据方式不同

网络设备可以是一个硬件设备，或者是软件设备，他没有相应的read write，它是面向流的一种特殊设备。

Ⅳ Linux输入设备驱动

输入设备（如按键、键盘、触摸屏、鼠标等）是典型的字符设备，其一般的工作机理是底层在按键、触摸等动作发送时产生一个中断（或驱动通过Timer定时查询)，然后CPU通过SPI、I-C或外部存储器总线读取键值、坐标等数据，并将它们放入一个缓冲区，字符设备驱动管理该缓冲区，而驱动的read ()接口让用户可以读取键值、坐标等数据。显然，在这些工作中，只是中断、读键值/坐标值是与设备相关的，而输入事件的缓冲区管理以及字符设备驱动的file operations接口则对输入设备是通用的。基于此，内核设计了输入子系统，由核心层处理公共的工作。drivers/input/keyboardgpio_keys.c基于input架构实现了一个通用的GPIO按键驱动。该驱动是基于platform_driver架构的，名为“gpio-keys”。它将与硬件相关的信息(如使用的GPIO号，按下和抬起时的电平等）屏蔽在板文件platform_device的platform_data中，因此该驱动可应用于各个处理器，具有良好的跨平台性。GPIO按键驱动通过input_event () 、input_sync()这样的函数来汇报按键事件以及同步事件。从底层的GPIO按键驱动可以看出，该驱动中没有任何file_operations的动作，也没有各种IO模型，注册进入系统也用的是input_register_device (）这样的与input相关的API。这是由于与Linux VFS接口的这一部分代码全部都在drivers/input/evdev.c中实现了。

Ⅵ 如何编写Linux操作系统的设备驱动程序

Linux是Unix操作系统的一种变种,在Linux下编写驱动程序的原理和
思想完全类似于其他的Unix系统,但它dos或window环境下的驱动程序有很大的
区别.在Linux环境下设计驱动程序,思想简洁,操作方便,功能也很强大,但是
支持函数少,只能依赖kernel中的函数,有些常用的操作要自己来编写,而且调
试也不方便.本人这几周来为实验室自行研制的一块多媒体卡编制了驱动程序,
获得了一些经验,愿与Linux fans共享,有不当之处,请予指正.
以下的一些文字主要来源于khg,johnsonm的Write linux device driver,
Brennan's Guide to Inline Assembly,The Linux A-Z,还有清华BBS上的有关
device driver的一些资料. 这些资料有的已经过时,有的还有一些错误,我依
据自己的试验结果进行了修正.
一. Linux device driver 的概念
系统调用是操作系统内核和应用程序之间的接口,设备驱动程序是操作系统
内核和机器硬件之间的接口.设备驱动程序为应用程序屏蔽了硬件的细节,这样
在应用程序看来,硬件设备只是一个设备文件, 应用程序可以象操作普通文件
一样对硬件设备进行操作.设备驱动程序是内核的一部分,它完成以下的功能:
1.对设备初始化和释放.
2.把数据从内核传送到硬件和从硬件读取数据.
3.读取应用程序传送给设备文件的数据和回送应用程序请求的数据.
4.检测和处理设备出现的错误.
在Linux操作系统下有两类主要的设备文件类型,一种是字符设备,另一种是
块设备.字符设备和块设备的主要区别是:在对字符设备发出读/写请求时,实际
的硬件I/O一般就紧接着发生了,块设备则不然,它利用一块系统内存作缓冲区,
当用户进程对设备请求读/写时,它首先察看缓冲区的内容,如果缓冲区的数据
能满足用户的要求,就返回请求的数据,如果不能,就调用请求函数来进行实际
的I/O操作.块设备是主要针对磁盘等慢速设备设计的,以免耗费过多的CPU时间
来等待.
已经提到,用户进程是通过设备文件来与实际的硬件打交道.每个设备文件都
都有其文件属性(c/b),表示是字符设备还蔤强樯璞?另外每个文件都有两个设
备号,第一个是主设备号,标识驱动程序,第二个是从设备号,标识使用同一个
设备驱动程序的不同的硬件设备,比如有两个软盘,就可以用从设备号来区分
他们.设备文件的的主设备号必须与设备驱动程序在登记时申请的主设备号
一致,否则用户进程将无法访问到驱动程序.
最后必须提到的是,在用户进程调用驱动程序时,系统进入核心态,这时不再是
抢先式调度.也就是说,系统必须在你的驱动程序的子函数返回后才能进行其他
的工作.如果你的驱动程序陷入死循环,不幸的是你只有重新启动机器了,然后就

Ⅶ linux驱动有哪些

1、将驱动程序文件bcm5700src.rpm复制到一个临时目录中，并在此目录中运行以下命令；

2、运行以下命令切换到驱动目录中；

3、此目录中会生成一个名字为bcm5700.spec的文件，运行以下命令对驱动程序进行编译；

4、运行以下命令切换到RPM目录中；

5、运行以下命令安装驱动程序；

6、运行以下命令加载驱动模块；

7、运行kudzu命令，系统会自动搜索到硬件，进行配置即可。

linux是文件型系统，在linux中，一切皆文件，所有硬件都会在对应的目录(/dev)下面用相应的文件表示。 文件系统的linux下面，都有对于文件与这些设备关联的，访问这些文件就可以访问实际硬件。 通过访问文件去操作硬件设备，一切都会简单很多，不需要再调用各种复杂的接口。 直接读文件，写文件就可以向设备发送、接收数据。 按照读写存储数据方式，我们可以把设备分为以下几种：字符设备（character device）、块设备（Block device）和网络设备（ network interface）。

字符设备（character device）:指应用程序采用字符流方式访问的设备。这些设备节点通常为传真、虚拟终端和串口调制解调器、键盘之类设备提供流通信服务， 它通常只支持顺序访问。字符设备在实现时，大多不使用缓存器。系统直接从设备读取/写入每一个字符。

块设备（Block device）:通常支持随机存取和寻址，并使用缓存器，支持mount文件系统。典型的块设备有硬盘、SD卡、闪存等，但此类设备一般不需要自己开发，linux对此提过了大部分的驱动。

网络设备（network interface）:是一种特殊设备，它并不存在于/dev下面，主要用于网络数据的收发。网络驱动同块驱动最大的不同在于网络驱动异步接受外界数据，而块驱动只对内核的请求作出响应。

上述设备中，字符设备驱动程序适合于大多数简单的硬件设备，算是各类驱动程序中最简单的一类，一般也是从这类驱动开始学习，然后再开始学习采用IIC、SPI等通讯接口的一些设备驱动。可以基于此类驱动调试LKT和LCS系列加密芯片。注意7位IIC地址是0x28。

Ⅷ 请教：linux 字符设备驱动IIC进不了中断

如何编写Linux设备驱动程序回想学习Linux操作系统已经有近一年的时间了，前前后后，零零碎碎的一路学习过来，也该试着写的东西了。也算是给自己能留下一点记忆和回忆吧！由于完全是自学的，以下内容若有不当之处，还请大家多指教。Linux是Unix操作系统的一种变种，在Linux下编写驱动程序的原理和思想完全类似于其他的Unix系统，但它dos或window环境下的驱动程序有很大的区别。在Linux环境下设计驱动程序，思想简洁，操作方便，功能也很强大，但是支持函数少，只能依赖kernel中的函数，有些常用的操作要自己来编写，而且调试也不方便。以下的一些文字主要来源于khg，johnsonm的Writelinuxdevicedriver，Brennan'sGuidetoInlineAssembly，TheLinuxA-Z，还有清华BBS上的有关devicedriver的一些资料。一、Linuxdevicedriver的概念系统调用是操作系统内核和应用程序之间的接口，设备驱动程序是操作系统内核和机器硬件之间的接口。设备驱动程序为应用程序屏蔽了硬件的细节，这样在应用程序看来，硬件设备只是一个设备文件，应用程序可以象操作普通文件一样对硬件设备进行操作。设备驱动程序是内核的一部分，它完成以下的功能:1、对设备初始化和释放。2、把数据从内核传送到硬件和从硬件读取数据。3、读取应用程序传送给设备文件的数据和回送应用程序请求的数据。4、检测和处理设备出现的错误。在Linux操作系统下有三类主要的设备文件类型，一是字符设备，二是块设备，三是网络设备。字符设备和块设备的主要区别是:在对字符设备发出读/写请求时，实际的硬件I/O一般就紧接着发生了，块设备则不然，它利用一块系统内存作缓冲区，当用户进程对设备请求能满足用户的要求，就返回请求的数据，如果不能，就调用请求函数来进行实际的I/O操作。块设备是主要针对磁盘等慢速设备设计的，以免耗费过多的CPU时间来等待。已经提到，用户进程是通过设备文件来与实际的硬件打交道。每个设备文件都都有其文件属性(c/b)，表示是字符设备还是块设备?另外每个文件都有两个设备号，第一个是主设备号，标识驱动程序，第二个是从设备号，标识使用同一个设备驱动程序的不同的硬件设备，比如有两个软盘，就可以用从设备号来区分他们。设备文件的的主设备号必须与设备驱动程序在登记时申请的主设备号一致，否则用户进程将无法访问到驱动程序。最后必须提到的是，在用户进程调用驱动程序时，系统进入核心态，这时不再是抢先式调度。也就是说，系统必须在你的驱动程序的子函数返回后才能进行其他的工作。如果你的驱动程序陷入死循环，不幸的是你只有重新启动机器了，然后就是漫长的fsck。读/写时，它首先察看缓冲区的内容，如果缓冲区的数据未被处理，则先处理其中的内容。如何编写Linux操作系统下的设备驱动程序二、实例剖析我们来写一个最简单的字符设备驱动程序。虽然它什么也不做，但是通过它可以了解Linux的设备驱动程序的工作原理。把下面的C代码输入机器，你就会获得一个真正的设备驱动程序。#define__NO_VERSION__#include#includecharkernel_version[]=UTS_RELEASE;这一段定义了一些版本信息，虽然用处不是很大，但也必不可少。Johnsonm说所有的驱动程序的开头都要包含，一般来讲最好使用。由于用户进程是通过设备文件同硬件打交道，对设备文件的操作方式不外乎就是一些系统调用，如open，read，write，close…，注意，不是fopen，fread，但是如何把系统调用和驱动程序关联起来呢?这需要了解一个非常关键的数据结构：structfile_operations{int(*seek)(structinode*，structfile*，off_t，int);int(*read)(structinode*，structfile*，char，int);int(*write)(structinode*，structfile*，off_t，int);int(*readdir)(structinode*，structfile*，structdirent*，int);int(*select)(structinode*，structfile*，int，select_table*);int(*ioctl)(structinode*，structfile*，unsinedint，unsignedlong);int(*mmap)(structinode*，structfile*，structvm_area_struct*);int(*open)(structinode*，structfile*);int(*release)(structinode*，structfile*);int(*fsync)(structinode*，structfile*);int(*fasync)(structinode*，structfile*，int);int(*check_media_change)(structinode*，structfile*);int(*revalidate)(dev_tdev);}这个结构的每一个成员的名字都对应着一个系统调用。用户进程利用系统调用在对设备文件进行诸如read/write操作时，系统调用通过设备文件的主设备号找到相应的设备驱动程序，然后读取这个数据结构相应的函数指针，接着把控制权交给该函数。这是linux的设备驱动程序工作的基本原理。既然是这样，则编写设备驱动程序的主要工作就是编写子函数，并填充file_operations的各个域。下面就开始写子程序。#include#include#include#include#include#includeunsignedinttest_major=0;staticintread_test(structinode*node，structfile*file，char*buf，intcount){intleft;if(verify_area(VERIFY_WRITE，buf，count)==-EFAULT)return-EFAULT;for(left=count;left>0;left--){__put_user(1，buf，1);buf++;}returncount;}这个函数是为read调用准备的。当调用read时，read_test()被调用，它把用户的缓冲区全部写1。buf是read调用的一个参数。它是用户进程空间的一个地址。但是在read_test被调用时，系统进入核心态。所以不能使用buf这个地址，必须用__put_user()，这是kernel提供的一个函数，用于向用户传送数据。另外还有很多类似功能的函数。请参考Robert着的《Linux内核设计与实现》（第二版）。然而，在向用户空间拷贝数据之前，必须验证buf是否可用。这就用到函数verify_area。staticintwrite_tibet(structinode*inode，structfile*file，constchar*buf，intcount){returncount;}staticintopen_tibet(structinode*inode，structfile*file){MOD_INC_USE_COUNT;return0;}staticvoidrelease_tibet(structinode*inode，structfile*file){MOD_DEC_USE_COUNT;}这几个函数都是空操作。实际调用发生时什么也不做，他们仅仅为下面的结构提供函数指针。structfile_operationstest_fops={NULL，read_test，write_test，NULL，/*test_readdir*/NULL，NULL，/*test_ioctl*/NULL，/*test_mmap*/open_test，release_test，NULL，/*test_fsync*/NULL，/*test_fasync*//*nothingmore，fillwithNULLs*/};这样，设备驱动程序的主体可以说是写好了。现在要把驱动程序嵌入内核。驱动程序可以按照两种方式编译。一种是编译进kernel，另一种是编译成模块(moles)，如果编译进内核的话，会增加内核的大小，还要改动内核的源文件，而且不能动态的卸载，不利于调试，所以推荐使用模块方式。intinit_mole(void){intresult;result=register_chrdev(0，"test"，&test_fops);if(result#include#include#includemain(){inttestdev;inti;charbuf[10];testdev=open("/dev/test"，O_RDWR);if(testdev==-1){printf("Cann'topenfile\n");exit(0);}read(testdev，buf，10);for(i=0;i<10;i++)printf("%d\n"，buf[i]);close(testdev);}编译运行，看看是不是打印出全1？以上只是一个简单的演示。真正实用的驱动程序要复杂的多，要处理如中断，DMA，I/Oport等问题。这些才是真正的难点。请看下节，实际情况的处理。如何编写Linux操作系统下的设备驱动程序三、设备驱动程序中的一些具体问题1。I/OPort。和硬件打交道离不开I/OPort，老的ISA设备经常是占用实际的I/O端口，在linux下，操作系统没有对I/O口屏蔽，也就是说，任何驱动程序都可对任意的I/O口操作，这样就很容易引起混乱。每个驱动程序应该自己避免误用端口。有两个重要的kernel函数可以保证驱动程序做到这一点。1）check_region(intio_port，intoff_set)这个函数察看系统的I/O表，看是否有别的驱动程序占用某一段I/O口。参数1：I/O端口的基地址，参数2：I/O端口占用的范围。返回值：0没有占用，非0，已经被占用。2）request_region(intio_port，intoff_set，char*devname)如果这段I/O端口没有被占用，在我们的驱动程序中就可以使用它。在使用之前，必须向系统登记，以防止被其他程序占用。登记后，在/proc/ioports文件中可以看到你登记的I/O口。参数1：io端口的基地址。参数2：io端口占用的范围。参数3：使用这段io地址的设备名。在对I/O口登记后，就可以放心地用inb()，outb()之类的函来访问了。在一些pci设备中，I/O端口被映射到一段内存中去，要访问这些端口就相当于访问一段内存。经常性的，我们要获得一块内存的物理地址。2。内存操作在设备驱动程序中动态开辟内存，不是用malloc，而是kmalloc，或者用get_free_pages直接申请页。释放内存用的是kfree，或free_pages。请注意，kmalloc等函数返回的是物理地址！注意，kmalloc最大只能开辟128k-16，16个字节是被页描述符结构占用了。内存映射的I/O口，寄存器或者是硬件设备的RAM(如显存)一般占用F0000000以上的地址空间。在驱动程序中不能直接访问，要通过kernel函数vremap获得重新映射以后的地址。另外，很多硬件需要一块比较大的连续内存用作DMA传送。这块程序需要一直驻留在内存，不能被交换到文件中去。但是kmalloc最多只能开辟128k的内存。这可以通过牺牲一些系统内存的方法来解决。3。中断处理同处理I/O端口一样，要使用一个中断，必须先向系统登记。intrequest_irq(unsignedintirq，void(*handle)(int，void*，structpt_regs*)，unsignedintlongflags，constchar*device);irq:是要申请的中断。handle：中断处理函数指针。flags：SA_INTERRUPT请求一个快速中断，0正常中断。device：设备名。如果登记成功，返回0，这时在/proc/interrupts文件中可以看你请求的中断。4。一些常见的问题。对硬件操作，有时时序很重要（关于时序的具体问题就要参考具体的设备芯片手册啦！比如网卡芯片RTL8139）。但是如果用C语言写一些低级的硬件操作的话，gcc往往会对你的程序进行优化，这样时序会发生错误。如果用汇编写呢，gcc同样会对汇编代码进行优化，除非用volatile关键字修饰。最保险的法是禁止优化。这当然只能对一部分你自己编写的代码。如果对所有的代码都不优化，你会发现驱动程序根本无法装载。这是因为在编译驱动程序时要用到gcc的一些扩展特性，而这些扩展特性必须在加了优化选项之后才能体现出来。写在后面：学习Linux确实不是一件容易的事情，因为要付出很多精力，也必须具备很好的C语言基础；但是，学习Linux也是一件非常有趣的事情，它里面包含了许多高手的智慧和“幽默”，这些都需要自己亲自动手才能体会到，O(∩_∩)O~哈哈！