其他分享
首页 > 其他分享> > 字符设备驱动:LED平台总线实现方式

字符设备驱动:LED平台总线实现方式

作者:互联网

1. 环境:

1.1 开发板:正点原子 I.MX6U ALPHA V2.2

1.2 开发PC:Ubuntu20.04

1.3 U-boot:uboot-imx-rel_imx_4.1.15_2.1.0_ga.tar.bz2

1.4 LInux内核:linux-imx-rel_imx_4.1.15_2.1.0_ga.tar.bz2

1.5 rootfs:busybox-1.29.0.tar.bz2制作

1.6 交叉编译工具链:gcc-linaro-4.9.4-2017.01-x86_64_arm-linux-gnueabihf.tar.xz

 

2. 硬件控制说明

2.1 由GPIO1 PIN3控制,高---熄灭, 低---点亮

 

3. 驱动代码

3.1 新建led.h头文件,添加如下代码

 1 #ifndef __LED_H
 2 #define __LED_H
 3 #include <linux/cdev.h>
 4 
 5 //GPIO寄存器地址,参考"i.MX 6ULL Applications Processor Reference Manual"
 6 #define LED_GPIO1_3_BASE        0x0209c000
 7 #define GPIO_DR                 0x0
 8 #define GPIO_GDIR               0x4
 9 #define GPIO_PSR                0x8         //本驱动未使用到
10 #define GPIO_ICR1               0xc         //本驱动未使用到
11 #define GPIO_ICR2               0x10        //本驱动未使用到
12 #define GPIO_IMR                0x14        //本驱动未使用到
13 #define GPIO_ISR                0x18        //本驱动未使用到
14 #define GPIO_EDGE_SEL           0x1c        //本驱动未使用到
15 
16 #define LED_GPIO1_3_MUX         0X020E0068      //GPIO复用功能选择寄存器地址
17 #define LED_GPIO1_3_PAD         0X020E02F4      //GPIO驱动方式选择寄存器地址
18 #define LED_GPIO1_3_CCM         0X020C406C      //GPIO时钟寄存器地址
19 
20 //led控制
21 #define LED_ON                  1
22 #define LED_OFF                 0
23 #define LED_MAJOR               249     //用于静态设备号申请
24 
25 
26 //自定义一个结构体,将一些需要的变量放在其中,以便管理
27 struct led_device
28 {
29     struct class *led_class;
30     struct device *led_device;
31     struct cdev led_cdev;  
32     dev_t   devno;
33     int major;                   //用于保存主设备号
34     void __iomem *led_dr;        //保存GPIO数据寄存器内存映射后的地址
35     void __iomem *led_gdir;      //保存GPIO输入输出方向选择寄存器内存映射后的地址
36     void __iomem *led_pd;        //保存GPIO驱动方式选择寄存器内存映射后的地址
37     void __iomem *led_mux;       //保存GPIO复用功能选择寄存器内存映射后的地址
38     void __iomem *led_ccm;       //保存GPIO时钟寄存器内存映射后的地址
39 };
40 
41 
42 #endif
View Code

 

3.2 新建led_dev_platform.c文件,添加平台设备代码

 1 #include <linux/init.h>
 2 #include <linux/module.h>
 3 #include <linux/ioport.h>
 4 #include <linux/platform_device.h>
 5 #include "led.h"
 6 
 7 //填充平台资源结构体
 8 struct resource led_resource[] = {
 9     [0] = {  //GPIO数据寄存器
10             .start  =   LED_GPIO1_3_BASE + GPIO_DR,
11             .end    =   LED_GPIO1_3_BASE + GPIO_DR + 4 -1,
12             .flags  =   IORESOURCE_MEM
13     },
14 
15     [1] = { //GPIO方向寄存器
16         .start  =    LED_GPIO1_3_BASE + GPIO_GDIR,
17         .end    =   LED_GPIO1_3_BASE + GPIO_GDIR + 4 -1,
18         .flags  =   IORESOURCE_MEM
19     },
20 
21     [2] = { //GPIO复用功能寄存器
22             .start  =   LED_GPIO1_3_MUX,
23             .end    =   LED_GPIO1_3_MUX + 4 -1,
24             .flags  =   IORESOURCE_MEM
25     },
26 
27     [3] = { //GPIO驱动方式寄存器
28         .start  =   LED_GPIO1_3_PAD,
29         .end    =   LED_GPIO1_3_PAD + 4 -1,
30         .flags  =   IORESOURCE_MEM
31     },
32 
33     [4] = { //GPIO时钟寄存器
34     .start  =   LED_GPIO1_3_CCM,
35     .end    =   LED_GPIO1_3_CCM + 4 -1,
36     .flags  =   IORESOURCE_MEM
37     },
38 
39 };
40 
41 
42 static void led_release(struct device *dev)
43 {
44 
45 }
46 
47 //填充平台结构体
48 struct platform_device led_gpio_device = {
49      .name           =   "led_gpio",
50   //  .name           =   "imx6ul-led",
51     .id             =   1,
52     .resource       =   led_resource,
53     .num_resources   =   ARRAY_SIZE(led_resource),
54     .dev            =   {
55         .release    =   led_release,
56     },
57 };
58 
59 
60 static int __init led_dev_platform_init(void)
61 {
62     //注册平台设备
63     platform_device_register(&led_gpio_device);  
64     return 0;
65 }
66 
67 
68 static void __exit led_dev_platform_exit(void)
69 {
70     //注销平台设备
71     platform_device_unregister(&led_gpio_device);
72 }
73 
74 
75 module_init(led_dev_platform_init);
76 module_exit(led_dev_platform_exit);
77 MODULE_LICENSE("Dual BSD/GPL");
View Code

 

3.3 新建led_drv_platform.c文件,添加平台驱动代码

  1 #include <linux/init.h>
  2 #include <linux/module.h>
  3 #include <linux/fs.h>           //文件操作函数,file_operarions
  4 #include <linux/device.h>       //设备申请函数,device_create
  5 #include <linux/platform_device.h>
  6 #include <linux/slab.h>         //内核空间申请函数件,kmalloc
  7 #include <asm/uaccess.h>        //内核与用户空间消息拷贝函数,copy_to_usser  &  copy_from_user
  8 #include <asm/io.h>             //内存地址映射函数,ioremap
  9 #include <linux/cdev.h>
 10 #include "led.h"
 11 
 12    
 13 static  struct led_device *imx_led_gpio1_3;
 14 
 15 //设备文件的open操作函数
 16 static  int led_open(struct inode *inode, struct file *file)
 17 {
 18 
 19     return 0;
 20 }
 21 
 22 //设备文件的close操作函数
 23 static int led_close(struct inode *inode, struct file *file)
 24 {
 25     return 0;
 26 }
 27 
 28 //设备文件的read操作函数
 29 static ssize_t led_read(struct file *file, char __user *buf, size_t size, loff_t *f_ops)
 30 {
 31     return 0;
 32 }
 33 
 34 //设备文件的write操作函数
 35 static ssize_t led_write(struct file *file, const char __user *buf, size_t size, loff_t *f_ops)
 36 {
 37     int ret;
 38     unsigned char cmd[1];
 39     u32 val = 0;
 40 
 41     ret = copy_from_user(cmd, buf, size);
 42     if(ret < 0) 
 43     {
 44         printk("kernel write failed!\r\n");
 45         return -EFAULT;
 46     }
 47 
 48 
 49    if(*cmd == LED_ON)
 50    {
 51         val = readl(imx_led_gpio1_3->led_dr);
 52         val &= ~(1 << 3);    
 53         writel(val, imx_led_gpio1_3->led_dr);
 54    }
 55    else if(*cmd == LED_OFF)
 56    {
 57         val = readl(imx_led_gpio1_3->led_dr);
 58         val|= (1 << 3);    
 59         writel(val, imx_led_gpio1_3->led_dr);
 60    }
 61    else
 62    {
 63        printk("led command is invalid!\n");
 64        return -2;
 65    } 
 66 
 67     return 0;
 68 }
 69 
 70 static long led_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 71 {
 72     u32 val = 0;
 73     switch (cmd)
 74     {
 75      case LED_OFF:
 76                 val = readl(imx_led_gpio1_3->led_dr);
 77                 val|= (1 << 3);    
 78                 writel(val, imx_led_gpio1_3->led_dr);
 79                 break;
 80     case LED_ON:
 81                 val = readl(imx_led_gpio1_3->led_dr);
 82                 val &= ~(1 << 3);    
 83                 writel(val, imx_led_gpio1_3->led_dr);
 84                 break;
 85     default:
 86                 val = readl(imx_led_gpio1_3->led_dr);
 87                 val|= (1 << 3);    
 88                 writel(val, imx_led_gpio1_3->led_dr);
 89                 break;
 90     }
 91 
 92 
 93     return 0;
 94 }
 95 
 96 //填充file_operations结构体
 97 static  const struct file_operations led_fops = {
 98     .owner               =   THIS_MODULE,
 99     .open                =   led_open,
100     .release             =   led_close,
101     .write               =   led_write,
102     .read                =   led_read,
103     .unlocked_ioctl      =   led_ioctl,
104 };
105 
106 
107 static int led_gpio_probe(struct platform_device *pdev)
108 {
109     int ret = -2;
110     int i;
111     u32 val = 0;
112     struct resource *res[5];
113     int ressize[5];
114 
115     //为自定义机构提申请内核内存
116     imx_led_gpio1_3 = kmalloc(sizeof(struct led_device), GFP_KERNEL);
117     if(imx_led_gpio1_3 == NULL)
118     {
119         printk(KERN_ERR "kmalloc fail!\n");
120         return -ENOMEM;
121     }
122 
123 
124     //ret = register_chrdev(LED_MAJOR, "led", &led_fops);
125     //如果使用动态申请,则必须使用cdev_init() & cdev_add()这两个函数;静态则不需要
126     ret = alloc_chrdev_region(&imx_led_gpio1_3->devno, 0, 1, "led");
127     if(ret < 0)
128     {
129         printk(KERN_ERR "register major failed!\n");
130         ret = -EINVAL;
131         goto err1;
132     }
133 
134 
135     imx_led_gpio1_3->major = MAJOR(imx_led_gpio1_3->devno);
136     imx_led_gpio1_3->led_cdev.owner = THIS_MODULE;
137 
138     //dev_major = MAJOR(devno);
139     imx_led_gpio1_3->led_cdev.owner = THIS_MODULE;
140 
141     //将设备与文件操作函数关联
142     cdev_init(&imx_led_gpio1_3->led_cdev, &led_fops);
143 
144     //注册设备
145     cdev_add(&imx_led_gpio1_3->led_cdev,imx_led_gpio1_3->devno, 1);
146 
147     //创建设备类
148     imx_led_gpio1_3->led_class = class_create(THIS_MODULE, "led_class");
149     if(IS_ERR(imx_led_gpio1_3->led_class))
150     {
151         printk(KERN_ERR "failed to create class!\n");
152         ret = PTR_ERR(imx_led_gpio1_3->led_class);
153         goto err2;
154     }
155 
156     
157     //创建设备文件,此函数最后一个参数led,其实就是设备名,应用程序open打开的也是这个文件名
158     imx_led_gpio1_3->led_device = device_create(imx_led_gpio1_3->led_class, NULL, imx_led_gpio1_3->devno, NULL, "led");
159     if(IS_ERR(imx_led_gpio1_3->led_device))
160     {
161         printk(KERN_ERR "failed to create device!\n");
162         ret = PTR_ERR(imx_led_gpio1_3->led_device);
163         goto err3;
164     }
165  
166    //获取设备资源
167    for(i = 0;  i < 5; i++)
168    {
169        res[i] =   platform_get_resource(pdev, IORESOURCE_MEM, i);
170        if(!res[i])
171        {
172            dev_err(&pdev->dev, "No MEM resource for always on \n");
173            return -ENXIO;
174        }
175        ressize[i] = resource_size(res[i]);
176    }
177     
178 
179     //对物理地址进行内存映射,以便后面操作
180     imx_led_gpio1_3->led_dr = ioremap(res[0]->start, ressize[0]);
181     if(imx_led_gpio1_3->led_dr == NULL)
182     {
183         printk(KERN_ERR "led_dr ioremap fail!\n");
184         ret = -ENOMEM;
185         goto err4;
186     }
187 
188     imx_led_gpio1_3->led_gdir = ioremap(res[1]->start, ressize[1]);
189     if(imx_led_gpio1_3->led_gdir == NULL)
190     {
191         printk(KERN_ERR "led_gdir ioremap fail!\n");
192         ret = -ENOMEM;
193         goto err4;
194     }
195 
196     imx_led_gpio1_3->led_mux = ioremap(res[2]->start, ressize[2]);
197     if(imx_led_gpio1_3->led_mux  == NULL)
198     {
199         printk(KERN_ERR "led_mux ioremap fail!\n");
200         ret = -ENOMEM;
201         goto err4;
202     }    
203 
204     imx_led_gpio1_3->led_pd = ioremap(res[3]->start, ressize[3]);
205     if(imx_led_gpio1_3->led_pd == NULL)
206     {
207         printk(KERN_ERR "led_pd ioremap fail!\n");
208         ret = -ENOMEM;
209         goto err4;
210     }
211 
212 
213     imx_led_gpio1_3->led_ccm = ioremap(res[4]->start, ressize[4]);
214     if(imx_led_gpio1_3->led_ccm == NULL)
215     {
216         printk(KERN_ERR "led_ccm ioremap fail!\n");
217         ret = -ENOMEM;
218         goto err4;
219     }
220 
221     // 使能GPIO1时钟 
222     val = readl(imx_led_gpio1_3->led_ccm);
223     val &= ~(3 << 26);    //清掉旧值
224     val |= (3 << 26);    // 设置新值
225     writel(val, imx_led_gpio1_3->led_ccm);
226 
227     // 将GPIO1_IO03复用功能设置为GPIO
228     writel(5, imx_led_gpio1_3->led_mux);
229 
230     // 设置GPIO的电流驱动能力
231     writel(0x10B0, imx_led_gpio1_3->led_pd);
232 
233    // 设置GPIO的输入输出方向 
234     val = readl(imx_led_gpio1_3->led_gdir);
235     val &= ~(1 << 3);    // 清除以前的设置
236     val |= (1 << 3);    // 设置为输出 
237     writel(val, imx_led_gpio1_3->led_gdir);
238 
239 
240     //设置LED的默认状态:LED熄灭 
241     val = readl(imx_led_gpio1_3->led_dr);
242     val |= (1 << 3);    
243     writel(val, imx_led_gpio1_3->led_dr);
244 
245     return 0;
246 
247 //注销设备节点
248 err4:
249     device_destroy(imx_led_gpio1_3->led_class, imx_led_gpio1_3->major);
250 
251 //注销设备类
252 err3:
253     class_destroy(imx_led_gpio1_3->led_class);
254 
255 //注销设备号
256 err2:
257     unregister_chrdev(imx_led_gpio1_3->major, "led");
258 
259 //释放由kmalloc申请的内存
260 err1:
261     kfree(imx_led_gpio1_3);
262     return ret;
263 
264 }
265 
266 
267 static int led_gpio_remove(struct platform_device *pdev)
268 {
269     device_destroy(imx_led_gpio1_3->led_class, imx_led_gpio1_3->major);
270     class_destroy(imx_led_gpio1_3->led_class);
271     unregister_chrdev(imx_led_gpio1_3->major, "led");
272     iounmap(imx_led_gpio1_3->led_dr);
273     iounmap(imx_led_gpio1_3->led_gdir);
274     iounmap(imx_led_gpio1_3->led_pd);
275     iounmap(imx_led_gpio1_3->led_mux);
276     iounmap(imx_led_gpio1_3->led_ccm);
277     kfree(imx_led_gpio1_3);
278 
279     return 0;
280 }
281 
282 struct platform_device_id led_ids[] = {
283     [0] =   {
284         .name           =   "led_gpio",
285         .driver_data    =   0,
286     },
287 };
288 
289 struct platform_driver led_gpio_driver = {
290     .probe  =   led_gpio_probe,
291     .remove =   led_gpio_remove,
292     .driver =   {
293         .owner  =   THIS_MODULE,
294         .name   =   "led_gpio"
295     },
296     .id_table   =   led_ids //当成员driver中的name成员不匹配时,从成员id_table中寻找
297 };
298 
299 static int __init led_init(void)
300 {
301     platform_driver_register(&led_gpio_driver);
302     return 0;
303 }
304 
305 static void __exit led_exit(void)
306 {   
307     platform_driver_unregister(&led_gpio_driver);
308 }
309 
310 module_init(led_init);
311 module_exit(led_exit);
312 MODULE_LICENSE("Dual BSD/GPL");
View Code

 

4. 测试代码

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <sys/types.h>
 4 #include <sys/stat.h>
 5 #include <fcntl.h>
 6 
 7 #define LED_ON                  1
 8 #define LED_OFF                 0
 9 
10 
11 int main(int argc, char **argv)
12 {
13     int fd;
14     int buf = 0;
15 
16     fd = open("/dev/led", O_RDWR);
17 
18     printf("fd = %d\n", fd);
19     if(fd < 0)
20     {
21         perror("open fail!\n");
22        
23         exit(1);
24     }
25 
26 #if 0
27 
28     if(strcmp(argv[1], "on") == 0)
29     {
30         if(ioctl(fd, LED_ON) < 0)
31             perror("ioctrl fail:led on\n");
32         else
33             printf("ioctl ok:led on\n");
34     }
35     else if(strcmp(argv[1], "off") == 0)
36     {
37         if(ioctl(fd, LED_OFF) < 0)
38              perror("ioctrl fail:led off\n");
39         else
40             printf("ioctl ok:led off\n");
41     }
42     else
43     {
44         perror("command is invalid!\n");
45     }
46 
47 
48 #else
49      if(strcmp(argv[1], "on") == 0)
50      {
51          buf = 1;
52         if(write(fd, &buf, sizeof(buf)) < 0)
53         {
54             perror("write fail:led on!\n");
55             exit(1); 
56         }
57         else
58         {
59             printf("write ok:led on!\n");         
60         }
61      }
62      else if(strcmp(argv[1], "off") == 0)
63      {
64          buf = 0;
65         if(write(fd, &buf, sizeof(buf)) < 0)
66         {
67             perror("write fail:led off!\n");
68             exit(1);
69         }
70         else
71         {
72             printf("write ok:led off!\n");
73         }
74      }
75      else
76     {
77         perror("command is invalid!\n");
78     }
79 
80 
81 #endif
82 
83     close(fd);
84     return 0;
85 }
View Code

 

总结:

1. 当平台设备有多个资源时,平台驱动需要逐个获取

2. 注意平台设备驱动与平台驱动匹配的条件

 

标签:字符,gpio1,led,GPIO,总线,imx,device,LED
来源: https://www.cnblogs.com/QSHL/p/15408522.html