Linux学习之LED驱动程序简介
linux驱动开发(一)
linux驱动开发(⼀)1:驱动开发环境要进⾏linux驱动开发我们⾸先要有linux内核的源码树,并且这个linux内核的源码树要和开发板中的内核源码树要⼀直;⽐如说我们开发板中⽤的是linux kernel内核版本为2.6.35.7,在我们ubuntu虚拟机上必须要有同样版本的源码树,我们再编译好驱动的的时候,使⽤modinfo XXX命令会打印出⼀个版本号,这个版本号是与使⽤的源码树版本有关,如果开发板中源码树中版本与modinfo的版本信息不⼀致使⽆法安装驱动的;我们开发板必须设置好nfs挂载;这些在根⽂件系统⼀章有详细的介绍;2:开发驱动常⽤的⼏个命令lsmod :list moduel 把我们机器上所有的驱动打印出来,insmod:安装驱动rmmod:删除驱动modinfo:打印驱动信息3:写linux驱动⽂件和裸机程序有很⼤的不同,虽然都是操作硬件设备,但是由于写裸机程序的时候是我们直接写代码操作硬件设备,这只有⼀个层次;⽽我们写驱动程序⾸先要让linux内核通过⼀定的接⼝对接,并且要在linux内核注册,应⽤程序还要通过内核跟应⽤程序的接⼝相关api来对接;4:驱动的编译模式是固定的,以后编译驱动的就是就按照这个模式来套即可,下⾯我们来分下⼀下驱动的编译规则:#ubuntu的内核源码树,如果要编译在ubuntu中安装的模块就打开这2个#KERN_VER = $(shell uname -r)#KERN_DIR = /lib/modules/$(KERN_VER)/build# 开发板的linux内核的源码树⽬录KERN_DIR = /root/driver/kernelobj-m += module_test.oall:make -C $(KERN_DIR) M=`pwd` modulescp:cp *.ko /root/porting_x210/rootfs/rootfs/driver_test.PHONY: cleanclean:make -C $(KERN_DIR) M=`pwd` modules cleanmake -C $(KERN_DIR) M=`PWD` modules这句话代码的作⽤就是到 KERN_DIR这个⽂件夹中 make modules把当前⽬录赋值给M,M作为参数传到主⽬录的Makefile中,实际上是主⽬录的makefile中有⽬标modules,下⾯有⼀定的规则来编译驱动;#KERN_VER = $(shell uname -r)#KERN_DIR = /lib/modules/$(KERN_VER)/build我们在ubuntu中编译内核的时候⽤这两句代码,因为在ubuntu中为我们保留了⼀份linux内核的源码树,我们编译的时候直接调⽤那个源码树的主Makefile以及⼀些头⽂件、内核函数等;了解规则以后,我们设置好KERN_DIR、obj-m这两个变量以后直接make就可以了;经过编译会得到下⾯⼀些⽂件:下⾯我们可以使⽤lsmod命令来看⼀下我们ubuntu机器现有的⼀些驱动可以看到有很多的驱动,下⾯我们使⽤insmod XXX命令来安装驱动,在使⽤lsmod命令看⼀下实验现象可以看到我们刚才安装的驱动放在了第⼀个位置;使⽤modinfo来打印⼀下驱动信息modinfo xxx.ko这⾥注意vermagic 这个的1.8.0-41是你⽤的linux内核源码树的版本号,只有这个编译的版本号与运⾏的linux内核版本⼀致的时候,驱动程序才会被安装注意license:GPL linux内核开元项⽬的许可证⼀般都是GPL这⾥尽量设置为GPL,否则有些情况下会出现错误;下⾯使⽤rmmod xxx删除驱动;-------------------------------------------------------------------------------------5:下⾯我们分析⼀下驱动。
led驱动程序设计流程
led驱动程序设计流程
LED驱动程序设计的基本流程大致如下:
1. 需求分析:首先,你需要明确你的LED驱动程序需要实现什么功能。
这可能包括亮度控制、颜色控制、动态效果等。
2. 选择合适的LED:根据你的需求,选择合适的LED型号。
这需要考虑LED的电压、电流需求,以及它的颜色和亮度特性。
3. 选择合适的电源:为LED提供稳定的电流和电压。
这可能是一个简单的线性电源或更复杂的开关电源。
4. 设计电路:设计驱动LED的电路。
这可能包括LED的正极和负极连接,以及任何需要的电阻或电容。
5. 编写代码:使用适当的编程语言(如C或Arduino语言)编写代码,以控制LED的行为。
这可能包括设置初始亮度、实现动态效果等。
6. 测试和调试:在开发过程中,你需要不断地测试和调试你的代码,以确保它按预期工作。
7. 优化和改进:一旦你的驱动程序开始工作,你可能会发现有改进的空间。
这可能包括提高效率、增加新功能、改进用户界面等。
8. 文档化:最后,记录你的设计决策、使用的元件、代码等,以便将来参考或他人使用。
以上就是LED驱动程序设计的基本流程,希望对你有所帮助。
Linux设备驱动程序原理及框架-内核模块入门篇
Linux设备驱动程序原理及框架-内核模块入门篇内核模块介绍应用层加载模块操作过程内核如何支持可安装模块内核提供的接口及作用模块实例内核模块内核模块介绍Linux采用的是整体式的内核结构,这种结构采用的是整体式的内核结构,采用的是整体式的内核结构的内核一般不能动态的增加新的功能。
为此,的内核一般不能动态的增加新的功能。
为此,Linux提供了一种全新的机制,叫(可安装) 提供了一种全新的机制,可安装) 提供了一种全新的机制模块” )。
利用这个机制“模块”(module)。
利用这个机制,可以)。
利用这个机制,根据需要,根据需要,在不必对内核重新编译链接的条件将可安装模块动态的插入运行中的内核,下,将可安装模块动态的插入运行中的内核,成为内核的一个有机组成部分;成为内核的一个有机组成部分;或者从内核移走已经安装的模块。
正是这种机制,走已经安装的模块。
正是这种机制,使得内核的内存映像保持最小,的内存映像保持最小,但却具有很大的灵活性和可扩充性。
和可扩充性。
内核模块内核模块介绍可安装模块是可以在系统运行时动态地安装和卸载的内核软件。
严格来说,卸载的内核软件。
严格来说,这种软件的作用并不限于设备驱动,并不限于设备驱动,例如有些文件系统就是以可安装模块的形式实现的。
但是,另一方面,可安装模块的形式实现的。
但是,另一方面,它主要用来实现设备驱动程序或者与设备驱动密切相关的部分(如文件系统等)。
密切相关的部分(如文件系统等)。
课程内容内核模块介绍应用层加载模块操作过程内核如何支持可安装模块内核提供的接口及作用模块实例内核模块应用层加载模块操作过程内核引导的过程中,会识别出所有已经安装的硬件设备,内核引导的过程中,会识别出所有已经安装的硬件设备,并且创建好该系统中的硬件设备的列表树:文件系统。
且创建好该系统中的硬件设备的列表树:/sys 文件系统。
(udev 服务就是通过读取该文件系统内容来创建必要的设备文件的。
)。
基于Linux的LED点阵应用程序设计
030 ) 6 00 料 学 院 ,河 北 石家 庄 0 04 ;4唐 山市 气 象 局 科 技服 务 中心 ,河 北 唐 山 503 .
’
.
卟 戋 卟 奖 。
卟 ‘
奖
装
明 Байду номын сангаас
驱动程序作为可加载的模块 ,由系统管理员动态加载,使之
成为核心的一部分。 编写驱动程序的主要工作就是编 写子 函
数,并填充 feop r to s各个域 。 i e ai n l
.
此应用程序 是在 L D 驱动加载之后使用 ,否则无法正 E 常运行 。本设计首先将 L D 点阵驱动起来 ,通过编写测试 E
,
(. ax e ooo i l ueuT n sa 6 3 0 C ia2C l g f c nmis n n ae n, h i ha g i a nvr 1 n i t rlgc ra, aghn0 4 0 , hn ; .ol e E o o c d Qi M e aB e o a Ma gme tS ia u e oU i - jz n T d e sy S iah ag0 04 , hn; .ol e f a r l c n e n n ier g S iah agTea nvri , h i h ag i, h i un 50 3 C i 3 lg M t i i c d gn ei , h i u idoU ie t S ia un t jz a C e o eaS e a E n jz n sy j z 0 0 3 C i ; . tooo i l cec dT cn lg et , aghnMeerl i l ueu T n sa 3 0 , hn) 50 , hn 4 4 a Meerl c i e eh o yC ne T n sa tooo c ra , agh 0 00 C ia g aS n a n o r g aB n 6
ledctl命令用法
ledctl命令用法LED(Light Emitting Diode,发光二极管)是一种常见的电子元件,广泛用于指示灯、显示屏等场景。
为了管理和控制LED的状态,我们可以使用ledctl命令来完成各种操作。
本文将介绍ledctl命令的基本用法以及常见的操作场景。
一、ledctl命令简介ledctl是一个Linux系统下的命令行工具,用于控制系统中的LED设备。
通过该命令,我们可以灵活地改变LED设备的状态,包括开启、关闭、设置亮度等。
ledctl命令的使用非常方便,只需提供相应的选项和参数即可完成操作。
二、ledctl命令的基本用法1. 查看系统中的LED设备要使用ledctl命令控制LED设备,首先需要了解系统中存在哪些LED设备。
可以通过以下命令查看系统中的LED设备列表:```ledctl -l```该命令会列出系统中所有的LED设备及其对应的编号和路径。
2. 开启和关闭LED设备使用ledctl命令可以方便地开启和关闭LED设备。
具体操作如下:```ledctl -n <设备编号> onledctl -n <设备编号> off```其中,<设备编号>为具体的LED设备编号,可以通过上一步骤获取到。
使用"on"参数可以将LED设备打开,使用"off"参数可以将LED 设备关闭。
3. 设置LED设备亮度某些情况下,我们可能需要调整LED设备的亮度级别。
ledctl命令提供了设置亮度的功能。
具体操作如下:```ledctl -n <设备编号> brightness <亮度级别>```其中,<设备编号>为具体的LED设备编号,<亮度级别>可以是一个介于0和255之间的整数。
根据设置的亮度级别,LED设备的亮度将会相应改变。
三、ledctl命令的常见操作场景1. 控制电源指示灯很多设备上都会有电源指示灯,通过ledctl命令可以方便地控制它的开关。
LINUX设备驱动开发详解
LINUX设备驱动开发详解概述LINUX设备驱动开发是一项非常重要的任务,它使得硬件设备能够与操作系统进行有效地交互。
本文将详细介绍LINUX设备驱动开发的基本概念、流程和常用工具,帮助读者了解设备驱动开发的要点和技巧。
设备驱动的基本概念设备驱动是连接硬件设备和操作系统的桥梁,它负责处理硬件设备的输入和输出,并提供相应的接口供操作系统调用。
设备驱动一般由设备驱动程序和设备配置信息组成。
设备驱动程序是编写解决设备驱动的代码,它负责完成设备初始化、IO操作、中断处理、设备状态管理等任务。
设备驱动程序一般由C语言编写,使用Linux内核提供的API函数进行开发。
设备配置信息是定义硬件设备的相关参数和寄存器配置的文件,它告诉操作系统如何与硬件设备进行交互。
设备配置信息一般以设备树或者直接编码在设备驱动程序中。
设备驱动的开发流程设备驱动的开发流程包括设备初始化、设备注册、设备操作函数编写和设备驱动注册等几个主要步骤。
下面将详细介绍这些步骤。
设备初始化设备初始化是设备驱动开发的第一步,它包括硬件初始化和内存分配两个主要任务。
硬件初始化是对硬件设备进行基本的初始化工作,包括寄存器配置、中断初始化等。
通过操作设备的寄存器,将设备设置为所需的状态。
内存分配是为设备驱动程序分配内存空间以便于执行。
在设备初始化阶段,通常需要为设备驱动程序分配一块连续的物理内存空间。
设备注册设备注册是将设备驱动程序与设备对象进行关联的过程,它使得操作系统能够正确地管理设备。
设备注册包括设备号分配、设备文件创建等操作。
设备号是设备在系统中的唯一标识符,通过设备号可以找到设备对象对应的设备驱动程序。
设备号分配通常由操作系统负责,设备驱动程序通过注册函数来获取设备号。
设备文件是用户通过应用程序访问设备的接口,它是操作系统中的一个特殊文件。
设备文件的创建需要通过设备号和驱动程序的注册函数来完成。
设备操作函数编写设备操作函数是设备驱动程序的核心部分,它包括设备打开、设备关闭、读和写等操作。
Linux内核背光backlight驱动架构文档
static void backlight_generate_event(struct backlight_device *bd, enum backlight_update_reason reason)
{ char *envp[2];
switch (reason) { case BACKLIGHT_UPDATE_SYSFS:
Backlight 子系统初始化驱动架构
本文要点: 1. input 子系统重要数据结构及关系图 2. input 子系统初始化驱动架构
背光控制原理
电源管理芯片是一个 LED 驱动器,相当于一个 LED 开关。MPU 通过操作 PWM 相关寄存器 来产生不同的波形,从而间接控制 LCD 背光灯的亮度。如下图:
backlight_class->dev_attrsdev_attrs = bl_device_attributes
backlight_class->dev_attrssuspend = backlight_suspend
backlight_class->dev_attrs =backlight_resume;
ppwwmm__bbll__ddaattaa{{}} .*pwm .period .*notify()
bbaacckklliigghhtt__pprrooppeerrttiieess{{}} .brightness .max_brightness .power .fb_blank .state
// data->pwm_id= smdk_backlight_device ->dev.platform_data->pwm_id pwm_bl_data ->pwm = pwm_request(data->pwm_id, "backlight"); // data->pwm_period_ns =smdk_backlight_device ->dev.platform_data->pwm_period_ns pb->period = data->pwm_period_ns
基于嵌入式Linux的LED驱动开发与应用
基于嵌入式Linux的LED驱动开发与应用摘要:简要介绍了基于嵌入式ARM处理器芯片LPC3250的嵌入式Linux的LED驱动程序的开发原理、流程以及相关主要接口硬件电路的设计。
实际运行结果表明,该设计完全达到预期效果。
关键词:嵌入式Linux;LED;硬件;驱动程序0引言随着IT技术和嵌入式技术的快速发展,嵌入式产品已经广泛应用于工业、能源、环保、通信等各个行业,显示出其强大的生命力。
Linux是当今流行的操作系统之一,具有源代码开放、内核稳定、功能强大和可裁减等优点而成为众多应用的首选。
同样嵌入式Linux也继承了Linux的诸多优点。
对Linux应用程序来说,由于设备驱动程序屏蔽了硬件的细节,其硬件设备将作为一个特殊的文件,因此应用程序可以像操作普通文件一样对硬件设备进行操作。
本设计中驱动的设备是基于NXP公司的LPC3250微处理器开发的LED信号指示灯,利用这些指示灯来显示仪器的运行状态,方便用户了解仪器的工作状况。
1LPC3250简介及接口电路设计本设计中主控芯片采用LPC3250微处理器,具有高集成度、高性能、低功耗等特点。
它采用90nm工艺和ARM926EJS内核,主频最高为208MHz,具有全系列标准外设。
其中包括带专用DMA控制器的24位LCD控制器,可支持STN和TFT面板。
充分满足本设计的需要,外部只需加入很少芯片就可实现系统功能<sup>[1]</sup>。
LPC3250共有296个管脚。
对于4个LED灯来说需要用到4个引脚,这里使用GPIO端口来设计,GPM1~GPM3作为LED灯的控制端口,另外还需要为LED提供电源,这里需要3.3V的直流电源。
接口电路设计如图1所示。
GPM0~GPM3分别与电阻、LED连接,当GPM0~GPM3置为低电平时,相应的LED灯点亮。
2驱动程序设计在嵌入式Linux操作系统下,有三类主要的设备文件类型:字符设备、块设备和网络设备<sup>[2]</sup>。
linux设备驱动程序--sysfs用户接口的使用
linux设备驱动程序--sysfs⽤户接⼝的使⽤linux sysfs⽂件系统本⽂部分内容参考⾃⾃2.6版本开始,linux内核开始使⽤sysfs⽂件系统,它的作⽤是将设备和驱动程序的信息导出到⽤户空间,⽅便了⽤户读取设备信息,同时⽀持修改和调整。
与ext系列和fat等⽂件系统不同的是,sysfs是⼀个系统在启动时构建在内存中虚拟⽂件系统,⼀般被挂载在/sys⽬录下,既然是存储在内存中,⾃然掉电不保存,不能存储⽤户数据。
事实上,在之前也有同样的虚拟⽂件系统建⽴了内核与⽤户系统信息的交互,它就是procfs,但是procfs并⾮针对设备和驱动程序,⽽是针对整个内核信息的抽象接⼝。
所以,内核开发⼈员觉得有必要使⽤⼀个独⽴的抽象接⼝来描述设备和驱动信息,毕竟直到⽬前,驱动代码在内核代码中占⽐⾮常⼤,内容也是⾮常庞杂。
这样可以避免procfs的混乱,⼦系统之间的分层和分离总是能带来更清晰地框架。
sysfs的默认⽬录结构上⽂中提到,sysfs⼀般被挂载在/sys⽬录下,我们可以通过ls /sys来查看sysfs的内容:block bus class dev devices firmware fs kernel module power⾸先需要注意的是,sysfs⽬录下的各个⼦⽬录中存放的设备信息并⾮独⽴的,我们可以看成不同的⽬录是从不同的⾓度来描述某个设备信息。
⼀个设备可能同时有多个属性,所以对于同⼀个驱动设备,同时存在于不同的⼦⽬录下,例如:在之前的章节中,我们使⽤create_dev_node.c编译出create_dev_node.ko模块,加载完成之后,我们可以在/sys下⾯看到当前驱动相关的⽬录:/sys/module/create_device_node//sys/class/basic_class/basic_demo (basic class为驱动程序中创建的class名称,basic_demo为设备名)/sys/devices/virtual/basic_class/basic_demo (basic class为驱动程序中创建的class名称,basic_demo为设备名)理解了这个概念,我们再来简览/sys各⽬录的功能:/sys/block:该⼦⽬录包含在系统上发现的每个块设备的⼀个符号链接。
Tiny-S3C6410_Linux下LED灯驱动移植过程
UT-S3C6410 ARM11 Linux 下的LED驱动一、实验环境操作系统:fedora13交叉编译环境:arm-Linux-gcc 或以上,6410板子内核源码路径在:忘了,需要厂家给的内核源代码硬件平台:S3C6410开发板(其他类型的开发板也可以注意配置GPIO)注:交叉编译环境一定要装好,一般的开发板给的配套资料中都会有,安装过程也都有详细的过程,如果没有,亲,你只有自己解决了。
也可以联系我(****************),泪奔支持你们。
二、实验原理控制LED是最简单的一件事情,就像学C语言时候写的“hello world”程序一样,是一个入门的程序。
首先来了解一下相关的硬件知识:UT-S3C6410LED原理图UT-S3C6410LED外部引脚图从上面的原理图可以得知,LED与CPU引脚的连接方法如下,高电平点亮。
LED1 -GPM0LED2 -GPM1LED3 -GPM2LED4 -GPM3从数据手册可以找到相应的控制方法。
这里我们以LED1为例,介绍一下LED1的操作方法,其他的类似,请大家自行分析。
通过上面可以得知,需要先将GPM0设置为输出方式。
将寄存器GPMCON低四位配置成0001。
然后将GPMDAT寄存器的第0位置1灯亮,置LED0灯亮,开发板上有四个LED所以要对GPMDAT的低四位进行操作,就可以实现对灯的亮灭操作了。
三、实验步骤1、编写驱动程序mini6410_leds.c#include <linux/miscdevice.h>#include <linux/delay.h>#include <asm/irq.h>//#include <mach/regs-gpio.h>#include <mach/hardware.h>#include <linux/kernel.h>#include <linux/module.h>#include <linux/init.h>#include <linux/mm.h>#include <linux/fs.h>#include <linux/types.h>#include <linux/delay.h>#include <linux/moduleparam.h>#include <linux/slab.h>#include <linux/errno.h>#include <linux/ioctl.h>#include <linux/cdev.h>#include <linux/string.h>#include <linux/list.h>#include <linux/pci.h>#include <asm/uaccess.h>#include <asm/atomic.h>#include <asm/unistd.h>#include <mach/map.h>#include <mach/regs-clock.h>#include <mach/regs-gpio.h>#include <plat/gpio-cfg.h>#include <mach/gpio-bank-e.h>#include <mach/gpio-bank-k.h>#define DEVICE_NAME "leds"static long sbc2440_leds_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) {switch(cmd) {unsigned tmp;case 0:case 1:if (arg > 4) {return -EINVAL;}tmp = readl(S3C64XX_GPKDAT);tmp &= ~(1 << (4 + arg));tmp |= ( (!cmd) << (4 + arg) );writel(tmp, S3C64XX_GPKDAT);//printk (DEVICE_NAME": %d %d\n", arg, cmd); return 0;default:return -EINVAL;}}static struct file_operations dev_fops = {.owner = THIS_MODULE,.unlocked_ioctl = sbc2440_leds_ioctl,};static struct miscdevice misc = {.minor = MISC_DYNAMIC_MINOR,.name = DEVICE_NAME,.fops = &dev_fops,};static int __init dev_init(void){int ret;{unsigned tmp;tmp = readl(S3C64XX_GPKCON);tmp = (tmp & ~(0xffffU<<16))|(0x1111U<<16); writel(tmp, S3C64XX_GPKCON);tmp = readl(S3C64XX_GPKDAT);tmp |= (0xF << 4);writel(tmp, S3C64XX_GPKDAT);}ret = misc_register(&misc);printk (DEVICE_NAME"\tinitialized\n");return ret;}static void __exit dev_exit(void){misc_deregister(&misc);}module_init(dev_init);module_exit(dev_exit);MODULE_LICENSE("GPL");MODULE_AUTHOR("FriendlyARM Inc.");(1)把Hello,Module 加入内核代码树,并编译一般编译2.6 版本的驱动模块需要把驱动代码加入内核代码树,并做相应的配置,如下步骤(注意:实际上以下步骤均已经做好,你只需要打开检查一下直接编译就可以了):Step1:编辑配置文件Kconfig,加入驱动选项,使之在make menuconfig 的时候出现打开linux-2.6.38/drivers/char/Kconfig 文件,添加如图所示:#====================cgf add===================================== config MINI6410_LEDStristate "LED Support for Mini6410 GPIO LEDs"depends on CPU_S3C6410default yhelpThis option enables support for LEDs connected to GPIO lineson Mini6410 boards.#================================================================== 保存退出,这时在linux-2.6.38 目录位置运行一下make menuconfig 就可以在DeviceDrivers Character devices 菜单中看到刚才所添加的选项了,按下空格键将会选择为<M>,此意为要把该选项编译为模块方式;再按下空格会变为<*>,意为要把该选项编译到内核中,在此我们选择<M>,如图,如果没有出现,请检查你是否已经装载了缺省的内核配置文件,(2)Makefile文件Step2:通过上一步,我们虽然可以在配置内核的时候进行选择,但实际上此时执行编译内核还是不能把mini6410_leds.c编译进去的,还需要在Makefile 中把内核配置选项和真正的源代码联系起来,打开linux-2.6.38-cgf/drivers/char/Makefile,obj-$(CONFIG_MINI6410_LEDS) += mini6410_leds.o添加并保存退出Step3:这时回到linux-2.6.38 源代码根目录位置,执行make modules,就可以生成我们所需要的内核模块文件drivers/char/mini6410_leds.ko 了,注意:执行make modules 之前,必须先执行make zImage,只需一次就可以了。
LED_KEY_Driver
LED设备驱动
static int __init dev_init(void) { int ret; int i; for (i = 0; i < 4; i++) { s3c2410_gpio_cfgpin(led_table[i], led_cfg_ table[i]); s3c2410_gpio_setpin(led_table[i], 0); } ret = misc_register(&misc); printk (DEVICE_NAME"\tinitialized\n"); return ret;
LED设备驱动
static int sbc2440_leds_ioctl( struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) { switch(cmd) { case 0: case 1: if (arg > 4) { return -EINVAL; } s3c2410_gpio_setpin(led_table[arg], !cmd); return 0; default: return -EINVAL; } }
KEY 设备驱动
int main(void) { int buttons_fd; char buttons[6] = {'0', '0', '0', '0', '0', '0'}; /*定义按键值变量*/ buttons_fd = open("/dev/buttons", 0); /*打开按键设备/dev/buttons*/ if (buttons_fd < 0) { perror("open device buttons"); /*打开失败则退出*/ exit(1); } /*永读按键并打印键值和状态*/
2-Linux驱动和内核模块编程
设备驱动的Hello World模块 设备驱动的 模块
模块卸载函数
static void __exit cleanup_function(void) { /* 释放资源 */ } module_exit(cleanup_function);
在模块被移除前注销接口并 释放所有所占用的系统资源
标识这个代码是只用于模块卸载( 标识这个代码是只用于模块卸载 通过使编译器把它放在 特殊的 ELF 段) 原型: 原型:#define __exit __attribute__ ((__section__(“.exit.text”)))
查看已加载模块
lsmod cat /proc/modules.
卸载驱动模块 卸载模块
从内核中卸载模块可以用rmmod工具.
注意,如果内核认为该模块任然在使用状态, 注意,如果内核认为该模块任然在使用状态,或 者内核被禁止移除该模块,则无法移除该模块。 者内核被禁止移除该模块,则无法移除该模块。
内核打印函数
隐藏硬件细节,提高应用软件的可移植性 提供安全性 开发模式 内核态驱动 用户态驱动
提供机制,而不是提供策略
机制:驱动程序能实现什么功能 策略:用户如何使用这些功能
设备的分类和特点Biblioteka 设备分类字符设备(char device) 字符设备 块设备(block device) 块设备 网络设备(network device) 网络设备
MODULE_LICENSE()---模块许可证声明 模块许可证声明
模块许可证(LICENSE)声明描述内核模块的许可权限 如果不声明LICENSE,模块被加载时,将收到内核被污染(kernel tainted)的警告
动手写一个内核模块
Linux驱动之LCD驱动编写
Linux驱动之LCD驱动编写在这篇博客中已经分析了编写LCD驱动的步骤,接下来就按照这个步骤来字尝试字节编写LCD驱动。
⽤的LCD屏幕为tft 屏,每个像素点为16bit。
对应与红绿蓝分别为565。
1、分配⼀个fb_info结构2、设置fb_info结构3、硬件相关的操作,配置LCD时钟、配置IO端⼝、配置LCD寄存器。
4、最终注册fbinfo结构到registered_fb数组要理解LCD的⼯作原理,需要了解LCD的时钟,在TFT的LCD中有如下的时钟。
这个⼏个时钟数据在配置LCD寄存器时都说需要设置的。
1、VCLK:两个像素之间的时钟,即两个像素隔多长时间才能显⽰下⼀个像素2、HSYNC:⽔平同步时钟,即第⼀⾏像素点显⽰完成之后隔多长时间才能开始下⼀⾏的显⽰3、VSYNC:垂直⽅向的同步时钟,也叫帧同步信号,即⼀帧数据显⽰完成之后(⼀帧数据表⽰⼀个屏幕显⽰完成,即⼀个显存的数据全部取完),过多长下⼀帧数据才开始显⽰本节需要⽤到的函数:void *dma_alloc_writecombine(struct device *dev, size_t size, dma_addr_t *handle, gfp_t gfp); //分配DMA缓存区给显存//返回值为:申请到的DMA缓冲区的虚拟地址,若为NULL,表⽰分配失败,则需要使⽤dma_free_writecombine()释放内存,避免内存泄漏//参数如下://*dev:指针,这⾥填0,表⽰这个申请的缓冲区⾥没有内容//size:分配的地址⼤⼩(字节单位)//*handle:申请到的物理起始地址//gfp:分配出来的内存参数,标志定义在<linux/gfp.h>,常⽤标志如下://GFP_ATOMIC ⽤来从中断处理和进程上下⽂之外的其他代码中分配内存. 从不睡眠.//GFP_KERNEL 内核内存的正常分配. 可能睡眠.//GFP_USER ⽤来为⽤户空间页来分配内存; 它可能睡眠.分配⼀段DMA缓存区,分配出来的内存会禁⽌cache缓存(因为DMA传输不需要CPU)它和 dma_alloc_coherent ()函数相似,不过 dma_alloc_coherent ()函数是分配出来的内存会禁⽌cache缓存以及禁⽌写⼊缓冲区dma_free_writecombine(dev,size,cpu_addr,handle); //释放缓存//cpu_addr:虚拟地址,//handle:物理地址释放DMA缓冲区, dev和size参数和上⾯的⼀样struct fb_info *framebuffer_alloc(size_t size, struct device *dev); //申请⼀个fb_info结构体,//size:额外的内存,//*dev:指针, 这⾥填0,表⽰这个申请的结构体⾥没有内容int register_framebuffer(struct fb_info *fb_info);//向内核中注册fb_info结构体,若内存不够,注册失败会返回负数int unregister_framebuffer(struct fb_info *fb_info) ;//注销内核中fb_info结构体本节需要⽤到的结构体:fb_info结构体如下:struct fb_info {... ...struct fb_var_screeninfo var; //可变的参数struct fb_fix_screeninfo fix; //固定的参数... ...struct fb_ops *fbops; //操作函数... ...char __iomem *screen_base; //显存虚拟起始地址unsigned long screen_size; //显存虚拟地址长度void *pseudo_palette;//假的16⾊调⾊板,⾥⾯存放了16⾊的数据,可以通过8bpp数据来找到调⾊板⾥⾯的16⾊颜⾊索引值,模拟出16⾊颜⾊来,节省内存,不需要的话就指向⼀个不⽤的数组即可 ... ...};其中操作函数fb_info-> fbops 结构体写法如下:static struct fb_ops s3c_lcdfb_ops = {.owner = THIS_MODULE,.fb_setcolreg = my_lcdfb_setcolreg,//设置调⾊板fb_info-> pseudo_palette,⾃⼰构造该函数.fb_fillrect = cfb_fillrect, //填充矩形,⽤/drivers/video/ cfbfillrect.c⾥的函数即可.fb_copyarea = cfb_copyarea, //复制数据, ⽤/drivers/video/cfbcopyarea.c⾥的函数即可.fb_imageblit = cfb_imageblit, //绘画图形, ⽤/drivers/video/imageblit.c⾥的函数即可};固定的参数fb_info-> fix 结构体如下:struct fb_fix_screeninfo {char id[16]; //id名字unsigned long smem_start; //framebuffer物理起始地址__u32 smem_len; //framebuffer长度,字节为单位__u32 type; //lcd类型,默认值0即可__u32 type_aux; //附加类型,为0__u32 visual; //画⾯设置,常⽤参数如下// FB_VISUAL_MONO01 0 单⾊,0:⽩⾊,1:⿊⾊// FB_VISUAL_MONO10 1 单⾊,1:⽩⾊,0:⿊⾊// FB_VISUAL_TRUECOLOR 2 真彩(TFT:真彩)// FB_VISUAL_PSEUDOCOLOR 3 伪彩// FB_VISUAL_DIRECTCOLOR 4 直彩 __u16 xpanstep; /*如果没有硬件panning就赋值为0 */ __u16 ypanstep; /*如果没有硬件panning就赋值为0 */ __u16 ywrapstep; /*如果没有硬件ywrap就赋值为0 */ __u32 line_length; /*⼀⾏的字节数 ,例:(RGB565)240*320,那么这⾥就等于240*16/8 */ /*以下成员都可以不需要*/ unsigned long mmio_start; /*内存映射IO的起始地址,⽤于应⽤层直接访问寄存器,可以不需要*/__u32 mmio_len; /* 内存映射IO的长度,可以不需要*/__u32 accel;__u16 reserved[3];};可变的参数fb_info-> var 结构体如下:structfb_var_screeninfo{ __u32xres; /*可见屏幕⼀⾏有多少个像素点*/__u32 yres; /*可见屏幕⼀列有多少个像素点*/__u32 xres_virtual; /*虚拟屏幕⼀⾏有多少个像素点 */__u32 yres_virtual; /*虚拟屏幕⼀列有多少个像素点*/__u32 xoffset; /*虚拟到可见屏幕之间的⾏偏移,若可见和虚拟的分辨率⼀样,就直接设为0*/ __u32 yoffset; /*虚拟到可见屏幕之间的列偏移*/__u32 bits_per_pixel; /*每个像素的位数即BPP,⽐如:RGB565则填⼊16*/__u32 grayscale; /*⾮0时,指的是灰度,真彩直接填0即可*/struct fb_bitfield red; //fb缓存的R位域, fb_bitfield结构体成员如下://__u32 offset; 区域偏移值,⽐如RGB565中的R,就在第11位//__u32 length; 区域长度,⽐如RGB565的R,共有5位//__u32 msb_right; msb_right ==0,表⽰数据左边最⼤, msb_right!=0,表⽰数据右边最⼤struct fb_bitfield green; /*fb缓存的G位域*/struct fb_bitfield blue; /*fb缓存的B位域*/ /*以下参数都可以不填,默认为0*/struct fb_bitfield transp; /*透明度,不需要填0即可*/__u32nonstd; /* != 0表⽰⾮标准像素格式*/__u32 activate; /*设为0即可*/__u32height; /*外设⾼度(单位mm),⼀般不需要填*/__u32width; /*外设宽度(单位mm),⼀般不需要填*/__u32 accel_flags; /*过时的参数,不需要填*//* 除了pixclock本⾝外,其他的都以像素时钟为单位*/__u32pixclock; /*像素时钟(⽪秒)*/__u32 left_margin; /*⾏切换,从同步到绘图之间的延迟*/__u32right_margin; /*⾏切换,从绘图到同步之间的延迟*/__u32upper_margin; /*帧切换,从同步到绘图之间的延迟*/__u32lower_margin; /*帧切换,从绘图到同步之间的延迟*/__u32hsync_len; /*⽔平同步的长度*/__u32 vsync_len; /*垂直同步的长度*/__u32 sync;__u32 vmode;__u32 rotate;__u32reserved[5]; /*保留*/}1.写驱动程序:(驱动设置:参考⾃带的LCD平台驱动drivers/video/s3c2410fb.c )1.1 步骤如下:在驱动init⼊⼝函数中:1)分配⼀个fb_info结构体2)设置fb_info 2.1)设置固定的参数fb_info-> fix 2.2) 设置可变的参数fb_info-> var 2.3) 设置操作函数fb_info-> fbops 2.4) 设置fb_info 其它的成员3)设置硬件相关的操作 3.1)配置LCD引脚 3.2)根据LCD⼿册设置LCD控制器 3.3)分配显存(framebuffer),把地址告诉LCD控制器和fb_info4)开启LCD,并注册fb_info: register_framebuffer() 4.1) 直接在init函数中开启LCD(后⾯讲到电源管理,再来优化) 控制LCDCON5允许PWREN信号, 然后控制LCDCON1输出PWREN信号, 输出GPB0⾼电平来开背光, 4.2) 注册fb_info在驱动exit出⼝函数中:1)卸载内核中的fb_info2) 控制LCDCON1关闭PWREN信号,关背光,iounmap注销地址3)释放DMA缓存地址dma_free_writecombine()4)释放注册的fb_info1.2 具体代码如下:#include <linux/module.h>#include <linux/kernel.h>#include <linux/fs.h>#include <linux/init.h>#include <asm/io.h> //含有iomap函数iounmap函数#include <asm/uaccess.h>//含有copy_from_user函数#include <linux/device.h>//含有类相关的处理函数#include <linux/fb.h> //含有fb_info结构体定义//#include <asm/dma-mapping.h> //含有dma_free_writecombine宏定义#include <linux/dma-mapping.h> //含有dma_free_writecombine宏定义#include <linux/platform_device.h>//含有平台设备总线模型相关变量#include <linux/mm.h>#include <linux/slab.h>//#include <linux/module.h>//#include <linux/kernel.h>//#include <linux/errno.h>//#include <linux/string.h>//#include <linux/mm.h>//#include <linux/slab.h>//#include <linux/delay.h>//#include <linux/fb.h>//#include <linux/init.h>//#include <linux/dma-mapping.h>//#include <linux/interrupt.h>//#include <linux/workqueue.h>//#include <linux/wait.h>//#include <linux/platform_device.h>//#include <linux/clk.h>//#include <asm/io.h>//#include <asm/uaccess.h>//#include <asm/div64.h>//#include <asm/mach/map.h>//#include <asm/arch/regs-lcd.h>//#include <asm/arch/regs-gpio.h>//#include <asm/arch/fb.h>/*lcd控制寄存器放在⼀个结构体⾥⾯*/struct lcd_regs {unsigned long lcdcon1;unsigned long lcdcon2;unsigned long lcdcon3;unsigned long lcdcon4;unsigned long lcdcon5;unsigned long lcdsaddr1;unsigned long lcdsaddr2;unsigned long lcdsaddr3;unsigned long redlut;unsigned long greenlut;unsigned long bluelut;unsigned long reserved[9];unsigned long dithmode;unsigned long tpal;unsigned long lcdintpnd;unsigned long lcdsrcpnd;unsigned long lcdintmsk;unsigned long lpcsel;};static struct fb_info *s3c_mylcdfb_info;//fb_info结构体static volatile unsigned long *gpbcon;//GPB0⽤于lcd背光的控制static volatile unsigned long *gpbdat;//GPB0⽤于lcd背光的控制static volatile unsigned long *gpccon;static volatile unsigned long *gpdcon;static volatile unsigned long *gpgcon;//GPG4⽤于lcd电源static volatile struct lcd_regs* lcd_regs;//lcd寄存器static u32 pseudo_palette[16]; //调⾊板内存/* from pxafb.c */static inline unsigned int chan_to_field(unsigned int chan, struct fb_bitfield *bf){chan &= 0xffff; //取出16bit的数据chan >>= 16 - bf->length; //return chan << bf->offset;}static int s3c_mylcdfb_setcolreg(unsigned int regno, unsigned int red,unsigned int green, unsigned int blue,unsigned int transp, struct fb_info *info){unsigned int val;if (regno > 16)return1;/* ⽤red,green,blue三原⾊构造出val */val = chan_to_field(red, &info->var.red);val |= chan_to_field(green, &info->var.green);val |= chan_to_field(blue, &info->var.blue);//((u32 *)(info->pseudo_palette))[regno] = val;pseudo_palette[regno] = val;return0;}static struct fb_ops s3c_mylcdfb_ops = { //操作函数结构体.owner = THIS_MODULE,.fb_setcolreg = s3c_mylcdfb_setcolreg,//待会设置,这个是调⾊板,如果使⽤⼩于16bit的像素需要⽤到 .fb_fillrect = cfb_fillrect,.fb_copyarea = cfb_copyarea,.fb_imageblit = cfb_imageblit,};static int lcd_drv_init(void){/*1、分配⼀个fb_info*/s3c_mylcdfb_info = framebuffer_alloc(0,NULL);//size为额外分配的⼤⼩,这⾥不需要,所以设为0if(s3c_mylcdfb_info==NULL){printk("unframebuffer_alloc\n");return1;}/*2、设置*//*2.1 设置固定的参数*/strcpy(s3c_mylcdfb_info->fix.id, "mylcd");//名字//s3c_mylcdfb_info->fix.smem_start = ;//显存的物理起始地址,后⾯设置s3c_mylcdfb_info->fix.smem_len = 480*272*16/8;//单位为字节,每个像素点占⽤16bit :565,显存的⼤⼩ s3c_mylcdfb_info->fix.type = FB_TYPE_PACKED_PIXELS;//LCD类型,填充像素的类型 tft//s3c_mylcdfb_info->fix.type_aux= //附加的LCD类型,不需要设置s3c_mylcdfb_info->fix.visual = FB_VISUAL_TRUECOLOR;//视觉类型,选择真彩⾊s3c_mylcdfb_info->fix.line_length = 480*16/8; //⼀⾏的长度,单位为字节// s3c_mylcdfb_info->fix.mmio_start = //控制lcd的寄存器的物理地址// s3c_mylcdfb_info->fix.mmio_len = //控制lcd的寄存器的⼤⼩/*2.2 设置可变的参数*/s3c_mylcdfb_info->var.xres = 480;//x⽅向的分辨率s3c_mylcdfb_info->var.yres = 272;//y⽅向的分辨率s3c_mylcdfb_info->var.xres_virtual = 480;//x⽅向的虚拟分辨率s3c_mylcdfb_info->var.yres_virtual = 272;//y⽅向的虚拟分辨率s3c_mylcdfb_info->var.bits_per_pixel = 16;//每个像素的⼤⼩,单位为bits3c_mylcdfb_info->var.grayscale = 0;//灰度值s3c_mylcdfb_info->var.red.length = 5;//红⾊像素占⽤的长度,单位bits3c_mylcdfb_info->var.green.length = 6;//绿⾊像素占⽤的长度,单位bits3c_mylcdfb_info->var.blue.length = 5;//蓝⾊像素占⽤的长度,单位bits3c_mylcdfb_info->var.red.offset= 11;//红⾊像素在16bit中的偏移值s3c_mylcdfb_info->var.green.offset= 6;//绿⾊像素在16bit中的偏移值s3c_mylcdfb_info->var.blue.offset=0;//蓝⾊像素在16bit中的偏移值s3c_mylcdfb_info->var.red.msb_right= 0;//低位在前还是⾼位在前,⼀般⾼位在前,也就是⼩端模式s3c_mylcdfb_info->var.green.msb_right= 0;s3c_mylcdfb_info->var.blue.msb_right=0;s3c_mylcdfb_info->var.activate = FB_ACTIVATE_NOW;//使⽤默认参数,显存⽴刻⽣效/*2.3 设置操作函数*/s3c_mylcdfb_info->fbops = &s3c_mylcdfb_ops;/*2.4 其它的⼀些设置 */s3c_mylcdfb_info->pseudo_palette = pseudo_palette;//调⾊板的地址//s3c_mylcdfb_info->screen_base = ;//显存的虚拟基地址s3c_mylcdfb_info->screen_size = 480*272*16/8;//单位为字节,每个像素点占⽤16bit :565,显存的⼤⼩/*3、硬件相关的操作 *//*3.1、配置GPIO⽤于LCD*/gpbcon = ioremap(0x56000010, 8);//将实际的寄存器地址转换为虚拟地址gpccon = ioremap(0x56000020 , 4);gpdcon = ioremap(0x56000030 , 4);gpgcon = ioremap(0x56000060 , 4);gpbdat = gpbcon + 1;*gpccon = 0xaaaaaaaa; /* GPIO管脚⽤于VD[7:0],LCDVF[2:0],VM,VFRAME,VLINE,VCLK,LEND */*gpdcon = 0xaaaaaaaa; /* GPIO管脚⽤于VD[23:8] */*gpbcon &= ~(3); /* GPB0设置为输出引脚 */*gpbcon |= 1;*gpbdat &= ~1; /* 输出低电平关闭LCD背光 */*gpgcon |= (3<<8); /* GPG4⽤作LCD_PWREN 电源*//*3.2、根据LCD⼿册设置LCD控制器,⽐如VCLK的频率等 */lcd_regs = ioremap(0X4D000000 , sizeof(struct lcd_regs));/** bit[17:8] : VCLK = HCLK / [(CLKVAL+1) x 2]* 10M = 100M/[(CLKVAL+1) x 2]* CLKVAL = 4** bit[6:5] :PNRMODE = 11显⽰模式,选择TFT模式** bit[4:1] :BPPMODE = 1100;像素=16bit 565** bit[0] :ENVID = 0;先关闭LCD控制器*/lcd_regs->lcdcon1 = (4<<8) | (3<<5) | (0x0c<<1);///** [31:24] : VBPD = 帧同步信号发出后,过多长时间开始显⽰数据,单位为⾏,理解为1⾏的时间* 看LCD⼿册tvb = VBPD + 1 = 2;所以VBPD = 1** [23:14]:LINEVAL + 1= 272;,所以LINEVAL = 271;垂直⽅向尺⼨,多少⾏** [13:6]:VFPD = ⼀帧的数据传输完成之后,过多长时间开始下⼀帧数据的帧同步信号,单位为⾏,理解为1⾏的时间 * 看LCD⼿册tvf = VFPD + 1 = 2;所以VFPD = 1** [5:0]:VSPW = 帧同步信号的脉冲宽度,单位为⾏* 看LCD⼿册tvp = VSPW + 1 =10;所以VSPW = 9*/lcd_regs->lcdcon2 = (1<<24) | (271<<14) | (1<<6) | (9<<0);/** [25:19]:HBPD = ⾏同步信号发出后,经过多少个VCLK,才发送像素的数据,单位为VCLK* 看LCD⼿册thb = HBPD + 1 = 2;所以HBPD=1** [18:8]:HOZVAL + 1 = 480,所以 HOZVAL = 479;⽔平⽅向尺⼨,多少列**[7:0]:HFPD = ⼀⾏的像素数据传输完成之后,经过多长时间,才能发送下⼀个⾏同步信号,单位为VCLK*看LCD⼿册thf = HFPD + 1 = 2;所以HFPD = 1;*/lcd_regs->lcdcon3 = (1<<19) | (479<<8) | (1<<0);/** [7:0]:HSPW = ⾏同步信号的脉冲宽度,单位为VCLK* 看LCD⼿册thp = HSPW + 1 = 41;所以HSPW = 40**/lcd_regs->lcdcon4 = (40<<0);/** [11] :FRM565 = 1;16位模式的格式 R:G:B = 5:6:5* [10] :INVVCLK = 0;VCLK在哪个边沿取数据 = 0表⽰下降沿取数据* [9] :INVVLINE = 1;⾏同步信号是否需要反转= 1需要反转* [8] :INVVFRAME = 1;帧同步信号是否需要反转= 1需要反转* [7] :INVVD = 0; 数据是否需要反转* [6] :INVVDEN = 0; 数据使能信号是否需要反转* [5] :INVPWREN = 0;电源使能信号是否需要反转* [4] :INVLEND = 0;⾏结束信号是否需要反转* [3] :PWREN = 0;电源使能信号,先不使能* [2] :ENLEND = 1;//⾏结束信号先使能* [1:0] :BSWP 、HWSWP = 0 1;字节内部不需要交换,字节间需要交换*/lcd_regs->lcdcon5= (1<<11) | (3<<8) | (1<<2) | (1<<0);/*3.3、显存和调⾊板设置 *//**利⽤dma_alloc_writecombine分配⼀块连续的显存*/s3c_mylcdfb_info->screen_base = dma_alloc_writecombine(NULL,s3c_mylcdfb_info->screen_size,(&(s3c_mylcdfb_info->fix.smem_start)),GFP_KERNEL);//返回虚拟地址if(s3c_mylcdfb_info->screen_base==NULL) //如果显存分配失败,直接返回{printk("undma_alloc_writecombine\n");return1;}/**将显存的地址告诉LCD控制器(物理地址)*/lcd_regs->lcdsaddr1 = (s3c_mylcdfb_info->fix.smem_start >> 1) & (~(3<<30));//起始地址lcd_regs->lcdsaddr2 = ((s3c_mylcdfb_info->fix.smem_start + s3c_mylcdfb_info->screen_size) >> 1) & 0x1fffff;//结束地址lcd_regs->lcdsaddr3 = (480*16/16); /* ⼀⾏的长度(单位: 2字节) *///s3c_lcd->fix.smem_start = xxx; /* 显存的物理地址 *//* 启动LCD */lcd_regs->lcdcon1 |= (1<<0); /* 使能LCD控制器 */lcd_regs->lcdcon5 |= (1<<3); /* 使能LCD本⾝电源 */*gpbdat |= 1; /* 输出⾼电平, 使能背光 *//*4、注册LCD*/register_framebuffer(s3c_mylcdfb_info);printk("register_framebuffer\n");return0;}static void lcd_drv_exit(void){unregister_framebuffer(s3c_mylcdfb_info);lcd_regs->lcdcon1 &= ~(1<<0); /* 关闭LCD本⾝ */*gpbdat &= ~1; /* 关闭背光 */dma_free_writecombine(NULL, s3c_mylcdfb_info->fix.smem_len, s3c_mylcdfb_info->screen_base, s3c_mylcdfb_info->fix.smem_start);iounmap(lcd_regs);iounmap(gpbcon);iounmap(gpccon);iounmap(gpdcon);iounmap(gpgcon);framebuffer_release(s3c_mylcdfb_info);}module_init(lcd_drv_init);module_exit(lcd_drv_exit);MODULE_LICENSE("GPL");2.重新编译内核,去掉默认的LCDmake menuconfig ,进⼊menu菜单重新设置内核参数:进⼊Device Drivers-> Graphics support:<M> S3C2410 LCD framebuffer support //将⾃带的LCD驱动设为模块, 不编进内核中然后make uImage 编译内核make modules 编译模块为什么要编译模块?因为LCD驱动相关的⽂件也没有编进内核,⽽fb_ops⾥的成员fb_fillrect(), fb_copyarea(), fb_imageblit()⽤的都是drivers/video下⾯的3个⽂件,所以需要这3个的.ko模块,如下图所⽰:3.挂载驱动将编译好的LCD驱动模块和drivers/video⾥的3个.ko模块放⼊nfs⽂件系统⽬录中然后烧写内核, 先装载3个/drivers/video下编译好的模块,再来装载LCD驱动模块挂载LCD驱动后, 如下图,可以通过 ls -l /dev/fb* 命令查看已挂载的LCD设备节点:4.测试运⾏测试有两种:echo hello> /dev/tty1 // LCD上便显⽰hello字段cat Makefile>/dev/tty1 // LCD上便显⽰Makeflie⽂件的内容4.1使⽤上节的键盘驱动在LCD终端打印命令⾏vi /etc/inittab //修改inittab, inittab:配置⽂件,⽤于启动init进程时,读取inittab添加->tty1::askfirst:-/bin/sh //将sh进程(命令⾏)输出到tty1⾥,也就是使LCD输出信息然后重启,insmod装载3个/drivers/video下编译好的模块,再来insmod装载LCD驱动模块,tty1设备便有了,就能看到提⽰信息:如下图,我们insmod上⼀节的键盘驱动后,按下enter键,便能在LCD终端上操作linux了从上图可以看到按下enter键,它就启动了⼀个进程号772的-sh进程,如下图发现这个-sh的描述符都指向了tty1:以上内容转载⾃。
嵌入式实验一:LED灯点亮
嵌⼊式实验⼀:LED灯点亮实验⼀:LED灯程序⼀、实验环境开发机环境操作系统:ubuntu 12.04交叉编译环境:arm-linux-gcc 4.3.26410板⼦内核源码:linux-3.0.1⽬标板环境:OK6410-A linux-3.0.1⼆、实验原理image.png图1-OK6410LED原理图image.png图2-LED原理图从上⾯的原理图可以得知,LED与CPU引脚的连接⽅法如下,低电平点亮。
LED1 -GPM0LED2 -GPM1LED3 -GPM2LED4 -GPM3image.png通过上⾯可以得知,需要先将GPM0设置为输出⽅式。
将相应的寄存器进⾏配置。
然后将GPMDAT寄存器的第0位置0灯亮,置1灯灭。
三、实验代码1.编写驱动程序#include <linux/module.h>#include <linux/kernel.h>#include <linux/fs.h>#include <asm/uaccess.h> /* copy_to_user,copy_from_user */#include <linux/miscdevice.h>#include <linux/pci.h>#include <mach/map.h>#include <mach/regs-gpio.h>#include <mach/gpio-bank-m.h>#include <plat/gpio-cfg.h>#define LED_MAJOR 240int led_open(struct inode *inode, struct file *filp){unsigned tmp;tmp = readl(S3C64XX_GPMCON);tmp = (tmp & ~(0x7U << 1)) | (0x1U);writel(tmp, S3C64XX_GPMCON);printk("#########open######\n");return 0;}ssize_t led_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos){printk("#########read######\n");return count;}ssize_t led_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos) {char wbuf[10];unsigned tmp;printk("#########write######\n");copy_from_user(wbuf, buf, count);switch (wbuf[0]){case 0: //offtmp = readl(S3C64XX_GPMDAT);tmp |= (0xfU);writel(tmp, S3C64XX_GPMDAT);break;case 1: //ontmp = readl(S3C64XX_GPMDAT);tmp &= ~(0xfU);writel(tmp, S3C64XX_GPMDAT);break;default:break;}return count;}int led_release(struct inode *inode, struct file *filp){printk("#########release######\n");return 0;}struct file_operations led_fops = {.owner = THIS_MODULE,.open = led_open,.read = led_read,.write = led_write,.release = led_release,};int __init led_init(void){int rc;printk("Test led dev\n");rc = register_chrdev(LED_MAJOR, "led", &led_fops);if (rc < 0){printk("register %s char dev error\n", "led");return -1;}printk("ok!\n");return 0;}void __exit led_exit(void){unregister_chrdev(LED_MAJOR, "led");printk("module exit\n");return;}module_init(led_init);module_exit(led_exit);2.编写Makefile⽂件ifneq ($(KERNELRELEASE),)obj-m := driver_led.oelseKDIR := /work/linux-3.0.1all:make -C $(KDIR) M=$(PWD) modules ARCH=arm CROSS_COMPILE=arm-linux-clean:rm -f *.ko *.o *.mod.o *.mod.c *.symversendif3.编写测试⽂件#include <stdio.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>int main (void){int fd;char buf[10]={0,1,0,1};fd = open("/dev/my_led",O_RDWR);if (fd < 0){printf ("Open /dev/my_led file error\n");return -1;}while(1){write(fd,&buf[0],1);sleep(1);write(fd,&buf[1],1);sleep(1);}close (fd);return 0;}四、实验步骤1、编译驱动程序和测试程序在终端中运⾏:#make命令,编译成功⽣⽣下列⽂件在终端中运⾏:#arm-linux-gcc test.c -o test,编译成功⽣成⽂件2、将⽂件拷贝到SD卡3、将SD卡插⼊到OK6410开发板中4、在OK6410终端中运⾏程序加载驱动:#insmod sdcard/driver_led.ko创建设备⽂件:# mknod /dev/my_led c 240 0运⾏测试⽂件:#./sdcard/test卸载驱动程序:#rmmod sdcard/driver_led.ko5、运⾏结果此时可以看到OK6410开发板的4个LED灯⼀直同时点亮,然后熄灭。
驱动学习1:第一个驱动入门
驱动学习1:第⼀个驱动⼊门Linux驱动程序,⾸先应该知道它是linux的内核模块。
Linux内核模块是使得复杂⽽庞⼤的linux内核条理清晰、可裁剪、⾼兼容性的重要特性。
Linux内核模块的特点:1,模块本⾝不被编译进内核镜像,能够控制内核的⼤⼩。
2,模块可以在需要的时候中被动态加载,⼀旦加载完成就和内核其它部分完全⼀样。
下⾯便是linux内核模块的helloworld程序,结构⼗分固定。
(1) 模块加载函数当通过insmod或者modprobe命令加载内核模块时,模块的加载函数会⾃动执⾏,完成本模块的相关初始化⼯作(2) 模块卸载函数当通过rmmod命令卸载内核模块时,模块的卸载函数会⾃动执⾏,完成本模块的卸载功能(3) 模块许可证声明如果不声明LICENSE,模块被加载时,将收到内核被污染(Kernel Tainted)的警告。
(4) 模块参数(可选)模块参数是模块被加载的时候可以传递给它的值,它本⾝对应模块内部的全部变量(5) 模块导出符号(可选)内核模块可以导出的符号(symbol,对应函数或变量),若导出,则其他模块可以使⽤本模块中的变量或函数(6) 模块作者等信息声明(可选)这个驱动并不具有任何控制硬件的⾏为,只是为了展⽰linux驱动的通⽤结构。
这⼏乎是所有驱动程序的通⽤模版,如led的驱动程序,只需要在hello_ioctl函数中根据不同的传⼊参数操作gpio寄存器即可。
(应⽤层没有操作硬件的权限,⽽内核中具有所有权限。
驱动程序的作⽤就是⾼效的、封装的、有限的向应⽤层提供服务)代码:1/*2hello.c - The simplest kernel module.3*/4 #include <linux/kernel.h>5 #include <linux/init.h>6 #include <linux/module.h>7 #include <linux/slab.h>8 #include <linux/io.h>9 #include <linux/interrupt.h>1011 #include <linux/of_address.h>12 #include <linux/of_device.h>13 #include <linux/of_platform.h>1415/* Standard module information */16 MODULE_LICENSE("GPL");17 MODULE_AUTHOR("pp.");18 MODULE_DESCRIPTION("hello module template ");1920#define DRIVER_NAME "hello"2122 unsigned myint = 0xdeadbeef;23char *mystr = "default";2425 module_param(myint, int, S_IRUGO);26 module_param(mystr, charp, S_IRUGO);2728static int __init hello_init(void)29 {30 printk(KERN_INFO "Hello module world.\n");31 printk(KERN_INFO "Module parameters were (0x%08x) and \"%s\"\n", myint,mystr);3233return0;34 }353637static void __exit hello_exit(void)38 {39 printk(KERN_ALERT "Goodbye module world.\n");40 }4142 module_init(hello_init);43 module_exit(hello_exit);编译后⽣成.ko⽂件,移植到开发板linux下测试默认情况下root@plnx_arm:/mnt# insmod hello.koHello module world.Module parameters were (0xdeadbeef) and "default"root@plnx_arm:/mnt# lsmodTainted: Ghello 8170 - Live 0xbf004000 (O)root@plnx_arm:/mnt# rmmod helloGoodbye module world.传⼊参数时:root@plnx_arm:/mnt# insmod hello.ko myint=123 mystr="pp"Hello module world.Module parameters were (0x0000007b) and "pp"root@plnx_arm:/mnt# rmmod helloGoodbye module world.通过其他的查询命令可以看到内核的输出:root@plnx_arm:/mnt# ls /sys/module/hello/parameters/myint mystrroot@plnx_arm:/mnt# tail -n 2 /var/log/messagesJun 409:56:33 plnx_arm kernel: Hello module world.Jun 409:56:33 plnx_arm kernel: Module parameters were (0x0000007b) and "pp"在Linux下可以通过两种⽅式加载驱动程序:静态加载和动态加载。
C语言嵌入式Linux开发驱动和系统调用
C语言嵌入式Linux开发驱动和系统调用在嵌入式系统领域中,C语言是最常用的编程语言之一。
它具有高效性、可移植性和灵活性,使得它成为开发嵌入式Linux驱动和系统调用的理想选择。
本文将详细介绍C语言在嵌入式Linux开发中的应用,包括驱动开发和系统调用的实现。
一、驱动开发1.1 驱动的定义和作用驱动是连接硬件和操作系统的关键组件,它允许操作系统与具体的硬件设备进行通信。
驱动的主要作用是提供对硬件设备的控制、管理和数据传输。
在嵌入式Linux系统中,驱动的开发需要使用C语言来编写。
1.2 驱动的开发流程驱动的开发可以分为以下几个步骤:1)了解硬件设备:首先要对驱动所涉及的硬件设备有一定的了解,包括设备的主要功能和寄存器的操作方式等。
2)驱动代码编写:使用C语言编写驱动代码,根据硬件设备的数据发送和接收过程设计函数和数据结构。
3)编译和链接:将驱动代码编译成可执行文件,并将其链接到操作系统的内核中。
4)加载和卸载:通过调用命令加载和卸载驱动,使其生效或失效。
5)测试和调试:进行驱动功能的测试和调试工作,确保驱动的正确性和稳定性。
1.3 驱动示例:LED驱动以一个简单的LED驱动为例,说明驱动的开发过程:1)定义LED设备的数据结构:创建一个结构体来表示LED设备的相关信息,例如设备的名称、设备的状态等。
2)实现LED控制函数:编写LED控制函数,通过操作硬件寄存器来控制LED的开关。
3)注册驱动:将驱动注册到操作系统的驱动框架中,使其与操作系统进行通信。
4)加载和卸载驱动:通过命令加载和卸载驱动,对LED进行控制。
二、系统调用2.1 系统调用的定义和作用系统调用是用户程序与操作系统之间的接口,它允许用户程序访问操作系统提供的服务和资源。
系统调用的主要作用是提供对底层硬件和操作系统功能的访问。
2.2 系统调用的分类系统调用可以分为以下几类:1)进程控制:如创建、终止和等待进程等。
2)文件操作:如打开、读取和关闭文件等。
ZedBoard_Linux开发_---_GPIO驱动详解ZedBoard 安装 Ubuntu11.04
ZedBoard Linux开发--- GPIO驱动详解下载LOFTER客户端本来这是要作为ZedBoard Linux的第一个学习实例,不过由于一开始实在找不到内核中针对ZedBoard GPIO具体操作的代码在哪里,所以只能先从OLED开始看起,在学习完OLED驱动之后有了不少发现,比如OLED驱动中就有使用GPIO的操作,后来发现这些操作都被Linux内核中的GPIOLIB库管理着,相关的文档在Documentation/gpio.txt中有介绍,通读一遍之后就会有不少发现的,相关的GPIOLIB库文件位于drivers/gpio/gpio-lib.c文件中,不过这部分文件只是提供了库函数,而真正在ZedBoard启动时进行GPIO注册管理的文件是drivers/gpio/gpio-xilinxps.c,可以在这个文件中找到这样一个宏定义:这里一共注册了118个GPIO口,看看Datasheet就知道这里的意思应该是MIO[0:53]+EMIO[54:117],也就是54个MIO加上64个EMIO,看到这里我还是有一些疑问,因为并不是所有的IO口都作为GPIO 来使用的,有很大一部分是进行IO复用的,下面是我在XPS中的MIO配置截图:可以看到MIO中真正作为GPIO口使用的也就只有MIO[0,7,9:15,50:51],我当时就有疑问:如果我在Linux中申请了这一部分被复用的GPIO,这会不会与正在复用的那些功能起冲突?(至少在MCU中有很多复用功能是在配置了GPIO方向之后才能正常复用的)后来看来一下zynq的UG585手册,找到了下面这张图才解决了问题:可以看到所有GPIO与其他复用的功能最后都是经过MIO网络路由到外部的GPIO端口的,也就是说即使在相应的GPIO寄存器中配置了GPIO的功能,那么这部分功能也不会生效!而配置这些复用功能的寄存器是在slcr(System Level Control Registers)寄存器中操作的,可以在UG585上找到这些寄存器具体的参数:而在Digilent Linux内核中,slcr相关的文件可以在linux-digilent/arch/arm/mach-zynq/slcr.c中找到。
linux学习步骤
第一阶段Linux系统管理与编程基础1. 嵌入式系统概述2. Linux介绍2. Linux定制安装3. Linux命令详解1. Linux系统管理2. Shell 编程3. Shell 编程综合实例-qcd1. GCC程序编译2. GDB程序调试3. Makefile 工程管理第二阶段应用程序设计1. Linux文件编程(系统调用)2. Linux文件编程(库函数)3. Linux时间编程1. Linux 进程基础2. Linux多进程程序设计1. 进程间通讯概述2. 管道通讯3. 信号通讯4. 共享内存通讯1. 消息队列通讯2. 信号灯1. Linux线程基础2. Linux线程创建3. Linux线程等待4. Linux线程清除1. IP协议分析2. TCP协议分析3. UDP协议分析4. TCP通讯程序设计5. UDP通讯程序设计6. 并发服务器模型7. 多路复用第三阶段ARM程序设计1. ARM处理器概述2. ARM处理器工作模式3. ARM系统寄存器4. ARM寻址方式5. ARM 汇编指令集6. ARM环境C语言编程7. ADS集成开发环境1. LED程序设计2. ARM中断与异常3. S3c2440 GPIO4. 按键程序设计5. 串口程序设计第四阶段Linux内核开发1. Linux内核简介2. Linux内核源代码结构3. Linux内核配置与裁剪4. Linux内核模块开发5. Linux内核启动流程1. 嵌入式Linux产品开发流程2. 交叉工具链3. Bootloader介绍4. U-Boot介绍5. U-Boot命令6. U-Boot工作原理7. U-Boot移植1. 嵌入式Linux内核制作2. 根文件系统制作3. 嵌入式文件系统介绍1. Linux内存管理2. Linux进程地址空间3. Linux内核地址空间4. Linux内核链表5. Linux内核定时器1. Linux进程控制2. Linux进程调度3. Linux系统调用4. Proc文件系统5. Linux内核异常分析第五阶段Linux驱动程序设计1.Linux驱动简介2.字符设备驱动程序设计3.驱动调试技术4. 并发与竞态1.Ioctl型驱动2.内核等待队列3. 阻塞型驱动程序设计4.Poll 设备操作1.Mmap设备操作2. 硬件访问3. 混杂设备驱动4. LED驱动程序设计1. Linux总线、设备、驱动模型2. Linux platform驱动3. 中断处理4. 按键驱动程序1.Linux网络体系架构2. Linux网卡驱动程序设计3. Dm9000网卡驱动程序分析4. 触摸屏驱动程序设计1. PCI驱动程序设计2. 串口驱动程序设计深入专题—SUB系统开发1. USB简介2. USB系统架构3. USB设备逻辑结构4. USB描述符5. USB传输6. USB枚举1. Linux USB系统架构2. Mass Storage3. USB HID4. RNDIS5. CDC/ACM1. USB驱动程序模型2. Linux USB描述符3. URB4. USB鼠标驱动程序详解深入专题—H。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
这里我们当然也要根据实际来思考我们的LED驱动程序。
在STM32点灯的时候,一般输出低电平点灯,输出高电平灭灯。
在嵌入Linux操作系统的情况下,我们自然也要想到有个写1/0的思想。
类比我们上一篇的hello程序:
我们的LED程序自然要写入的数据为0/1来点亮、熄灭LED。
这里我们做的实验室与硬件无关的LED实验:我们的驱动程序在收到应用程序发送过来的0时打印led on、收到1时打印led off。
模仿上一篇的hello程序,我们修改得到的与硬件无关的LED程序(核心部分)如下:
LED应用程序:
LED驱动程序:
加载led驱动模块及运行应用程序:
与硬件有关的LED驱动
上面那一节分享的是与硬件无关的LED驱动实验,主要是为了理清LED驱动的大体思路。
这里我们再加入与硬件有关的相关操作以构造与硬件有关的LED驱
动程序。
我们在进行STM32的裸机编程的时候,对一些外设进行配置其实就是操作一些地址的过程,这些外设地址在芯片手册中可以看到:
这是地址映射图,这里图中只是列出的外设的边界地址,每个外设又有很多寄存器,这些寄存器的地址都是对外设基地址进行偏移得到的。
同样的,对于NXP 的IMX6ULL芯片来说,也是有类似这样的地址的:
此时我们要编写Linux系统下的led驱动,涉及到硬件操作的地方操作的并不是这些地址(物理地址),而是操作系统给我们提供的地址(虚拟地址)。
操作系统根据物理地址来给我们生成一个虚拟地址,我们的led驱动操控这个地址就是间接的操控物理地址。
至于这两个地址是怎么联系起来的,里面个原理我们暂且不展开。
我们从函数层面来看,内核给我们提供了ioremap 函数,这个函数可以把物理地址映射为虚拟地址。
这个函数在内核文件arch/arm/include/asm/io.h 中:void __iomem *ioremap(resource_size_t res_cookie, size_t size); •res_cookie:要映射给的物理起始地址。
•size:要映射的内存空间大小。
•返回值:指向映射后的虚拟空间首地址。
与ioremap函数相对应的函数为:
void iounmap (volatile void __iomem *addr)
•addr:要取消映射的虚拟地址空间首地址。
地址映射完成之后,我们可以直接通过指针来访问虚拟地址,如:
*GPIO5_DR &= ~(1 << 3); /* GPIO5_IO03输出低电平 */
*GPIO5_DR |= (1 << 3); /* GPIO5_IO03输出高电平 */
这里简单介绍一下i.MX 6ULL的GPIO。
对于i.MX 6ULL来说,以数字来给
IO端口(组别)命令,GPIO5为第五组,所以GPIO5_IO03为第五组端口的第3个引脚。
而STM32中是以大写字母来表示端口(组别),如PA3表示A端口的第3个引脚。
i.MX 6ULL有 5 组 GPIO(GPIO1~ GPIO5),每组引脚最多有 32 个:
GPIO1 有 32 个引脚:GPIO1_IO0~GPIO1_IO31;
GPIO2 有 22 个引脚:GPIO2_IO0~GPIO2_IO21;
GPIO3 有 29 个引脚:GPIO3_IO0~GPIO3_IO28;
GPIO4 有 29 个引脚:GPIO4_IO0~GPIO4_IO28;
GPIO5 有 12 个引脚:GPIO5_IO0~GPIO5_IO11;
地址映射完成之后,我们不仅可以通过指针来访问虚拟地址,而且还可以使用内
核给我们提供的一些读写函数:
/* 写操作函数 */
void writeb(u8 value, volatile void __iomem *addr);
void writew(u16 value, volatile void __iomem *addr);
void writel(u32 value, volatile void __iomem *addr);
/* 读操作函数 */
u8 readb(const volatile void __iomem *addr);
u16 readw(const volatile void __iomem *addr);
u32 readl(const volatile void __iomem *addr);
writeb、 writew 和 writel 这三个函数分别对应 8bit、 16bit 和 32bit 写操作,参数 value 是要写入的数值, addr 是要写入的地址。
readb、 readw 和 readl 这三个函数分别对应 8bit、 16bit 和 32bit 读操作,参数 addr 就是要读取写内存地址,返回值就是读取到的数据。
此时我们可以把上一节的led_init函数led_drv_write函数进行修改:
与STM32一样,对于i.MX 6ULL的GPIO外设来说,也有很多寄存器:
上面我们只是点一个灯,如果是要点多个灯呢?那就得操控多个GPIO。
如果进行地址映射的写法还像上面那样,代码就会显得很臃肿。
回想一下我们STM32,GPIO外设通过结构体来管理它的寄存器:
这里的__IO是个宏,代表的是C语言的关键字volatile ,为了防止编译
器对我们的一些硬件操作进行优化,从而得不到想要的结果。
比如:
/* 假设REG为寄存器的地址 */
uint32 *REG;
*REG = 0;/* 点灯 */
*REG = 1;/* 灭灯 */
此时若是REG不加volatile进行修饰,则点灯操作将被优化掉,只执行灭灯操作。
在这里,我们也可以模仿STM32那样子,用一个结构体来对i.MX 6ULL的GPIO
的寄存器进行管理,如:
struct GPIO_RegDef
{
volatile unsigned int DR;
volatile unsigned int GDIR;
volatile unsigned int PSR;
volatile unsigned int ICR1;
volatile unsigned int ICR2;
volatile unsigned int IMR;
volatile unsigned int ISR;
volatile unsigned int EDGE_SEL;
};
结构体里的成员排序是要按照特定顺序来的:
因为这些寄存器都是相对于GPIO外设的基地址作偏移得到的,比如:
不能打乱顺序,否则就不能正确访问到对应的寄存器了。
用结构体进行管理
之后,我们就可以用类似下面的方式进行映射:
struct GPIO_RegDef *GPIO5 = ioremap(0x20AC000, sizeof(struct
GPIO_RegDef));
然后就可以向STM32那样来操控GPIO寄存器,如:
GPIO5->DR &= ~(1 << 3); /* GPIO5_IO03输出低电平 */
GPIO5->DR |= (1 << 3); /* GPIO5_IO03输出高电平 */
LED驱动(升级版)
上一节我们分享的LED驱动是一个常规的LED驱动,只能适用于我们当前的开发版,所以是一个专用的LED驱动程序。
若是换了另一块板,led所连接的gpio 引脚可能不一样了,我们就修改我们的驱动程序led_drv.c里与寄存器相关的操作。
有没有更好的办法不用再修改我们的led_drv.c驱动程序了?
若是led_drv.c不用再修改了,那么这个led_drv.c驱动就是一个通用的驱动程序了。
下面来简单地梳理一下:。