ioremap完成GPIO的输出控制。

为BBB写了一个小驱动，用ioremap完成的，可以用宏定义GPIOX1_X2,，程序如下：

1. #include
   
2. #include
   
3. #include
   
4. #include
   
5. #include
   
6. #include
   
7. #include
   
8. #include
   
9. #include
   
10. #include
    
11. #include
    
12. 
    
13. #define GPIOGROUP_NUM 4
    
14. //#define GPIO1_BASE 0x4804c000
    
15. #define GPIO_OE_OFFSET 0x134
    
16. #define GPIO_DATAOUT_OFFET 0X13c
    
17. /*修改GPIO_MA(对应GPIO0~GPIO3) GPIO_MI(对应0~31)) GPIO_NUM=GPIO_MA*32+GPIO_MI*/
    
18. #define GPIO_MA 1
    
19. #define GPIO_MI 28
    
20. #define GPIO_NUM 0
    
21. 
    
22. #define GPIOLED_NUM 1
    
23. 
    
24. #define NAME_LEN 16
    
25. #define GPIOLED_MAJOR 0
    
26. 
    
27. #define MKGPIONUM(ma,mi) (ma * 32 + mi)
    
28. #define MAGPIO(num) (num / 32)
    
29. #define MIGPIO(num) (num % 32)
    
30. 
    
31. static unsigned int gpiobase[GPIOGROUP_NUM] = {0x44E07000, 0x4804C000, 0x481AC000, 0x481AE000};
    
32. 
    
33. static unsigned int gpio_oe,gpio_dataout;
    
34. static char gpio_ma, gpio_mi;
    
35. static int major = GPIOLED_MAJOR;
    
36. static dev_t devnum;
    
37. static struct class *gpioled_class;
    
38. 
    
39. 
    
40.        
    
41. struct gpioled_dev{
    
42.         struct cdev cdev;
    
43.         char name[NAME_LEN];
    
44.         //unsigned int gpio_num;
    
45.         char gpio_ma;
    
46.         char gpio_mi;
    
47.         struct device *gpioled_device;
    
48. };
    
49. 
    
50. static struct gpioled_dev *gpioled_devp;
    
51. 
    
52. 
    
53. static int gpioled_open(struct inode *inode, struct file *filp)
    
54. {
    
55.         int ret = 0;
    
56.         unsigned int value_tmp;
    
57.         filp->private_data = container_of(inode->i_cdev, struct gpioled_dev, cdev);
    
58.         struct gpioled_dev *devp = filp->private_data;
    
59.         value_tmp = readl(gpio_dataout);
    
60.         printk("gpioled open and gpio%d_outdata:0x%lx.n",MKGPIONUM(devp->gpio_ma, devp->gpio_mi),(unsigned long)value_tmp);
    
61.         return ret;       
    
62. }
    
63. 
    
64. static ssize_t gpioled_read(struct file *filp,char __user *buf,size_t count,loff_t *ppos)
    
65. {
    
66.         unsigned int value_tmp;
    
67.         struct gpioled_dev *devp = filp->private_data;
    
68.         value_tmp = readl(gpio_dataout);
    
69.         if(copy_to_user(buf,&value_tmp,sizeof(value_tmp)))
    
70.                 printk(KERN_INFO "read failed!n");
    
71.         else
    
72.         {
    
73.                 *ppos+=sizeof(value_tmp);
    
74.                 printk(KERN_INFO "%s open and outdata:0x%lx.n",devp->name, (unsigned long)value_tmp);
    
75.         }
    
76.         return 0;
    
77. }
    
78. 
    
79. static ssize_t gpioled_write (struct file *filp, const char __user *buf, size_t count, loff_t *ppos)
    
80. {
    
81.         char value;
    
82.         struct gpioled_dev *devp = filp->private_data;
    
83.         copy_from_user(&value, buf, sizeof(value));
    
84.         if(value == '1')
    
85.                 writel((1<gpio_mi),gpio_dataout);
    
86.         else if(value == '0')
    
87.                 writel((0<gpio_mi),gpio_dataout);
    
88.         else
    
89.                 printk("no valid value value:%d.n",value);
    
90.        
    
91.         return sizeof(value);
    
92. }
    
93. 
    
94. static int gpioled_release(struct inode *inode, struct file *filp)
    
95. {
    
96.         int ret = 0;
    
97.        
    
98.         return ret;
    
99. }
    
100. 
     
101. static struct file_operations gpioled_fops = {
     
102.         .owner = THIS_MODULE,
     
103.         .open = gpioled_open,
     
104.         .read = gpioled_read,
     
105.         .write = gpioled_write,
     
106.         .release =  gpioled_release,
     
107. };
     
108. 
     
109. static void gpioled_setup(struct gpioled_dev * devp, int index)
     
110. {
     
111.         int ret = 0;
     
112.         devnum = MKDEV(major,index);
     
113.         cdev_init(&devp->cdev,&gpioled_fops);
     
114.         devp->cdev.owner = THIS_MODULE;
     
115.         ret = cdev_add(&devp->cdev,devnum,1);
     
116.         if(ret)
     
117.         {
     
118.                 printk(KERN_INFO "Error %d adding gpioled%d.n",ret, index);
     
119.         }
     
120.         else
     
121.         {               
     
122.                 devp->gpio_ma = gpio_ma;
     
123.                 devp->gpio_mi = gpio_mi;
     
124.                 sprintf(devp->name,"gpio%d_%d",devp->gpio_ma, devp->gpio_mi);
     
125.                 devp->gpioled_device = device_create(gpioled_class, NULL, devnum,NULL,devp->name);
     
126.                 printk(KERN_INFO "%s init.n",devp->name);
     
127.         }       
     
128. }
     
129. static int __init gpioled_init(void)
     
130. {
     
131.         int i, ret = 0;
     
132.         unsigned int value_tmp;
     
133.         if(GPIO_NUM != 0)
     
134.         {
     
135.                 gpio_ma = MAGPIO(GPIO_NUM);
     
136.                 gpio_mi = MIGPIO(GPIO_NUM);
     
137.         }
     
138.         else
     
139.         {
     
140.                 gpio_ma = GPIO_MA;
     
141.                 gpio_mi = GPIO_MI;
     
142.         }
     
143.         if(request_mem_region(gpiobase[gpio_ma] | GPIO_OE_OFFSET,sizeof(int),"GPIO_OE"))
     
144.         {
     
145.                 ret = -EBUSY;
     
146.                 goto fail;
     
147.         }
     
148.         if(request_mem_region(gpiobase[gpio_ma] | GPIO_DATAOUT_OFFET,sizeof(int),"GPIO_DATAOUT"))
     
149.         {
     
150.                 ret = -EBUSY;
     
151.                 goto fail;
     
152.         }
     
153.         gpio_oe = ioremap(gpiobase[gpio_ma] | GPIO_OE_OFFSET,sizeof(int));
     
154.         if(gpio_oe == NULL)
     
155.         {
     
156.                 release_mem_region(gpiobase[gpio_ma] | GPIO_OE_OFFSET,sizeof(int));
     
157.                 ret = -ENOMEM;
     
158.                 goto fail;
     
159.         }
     
160.         gpio_dataout = ioremap(gpiobase[gpio_ma] | GPIO_DATAOUT_OFFET,sizeof(int));
     
161.         if(gpio_dataout == NULL)
     
162.         {
     
163.                 release_mem_region(gpiobase[gpio_ma] | GPIO_DATAOUT_OFFET,sizeof(int));
     
164.                 ret = -ENOMEM;
     
165.                 goto fail;
     
166.         }
     
167.         if(major)
     
168.         {
     
169.                 devnum = MKDEV(major,0);
     
170.                 ret = register_chrdev_region(devnum,GPIOLED_NUM,"gpioled");
     
171.         }
     
172.         else
     
173.         {
     
174.                 ret = alloc_chrdev_region(&devnum,0,GPIOLED_NUM,"gpioled");
     
175.                 major = MAJOR(devnum);
     
176.         }
     
177.         if(ret < 0)
     
178.         {
     
179.                 goto fail;
     
180.         }
     
181.         gpioled_devp = kzalloc(sizeof(struct gpioled_dev) * GPIOLED_NUM,GFP_KERNEL);
     
182.         if(IS_ERR(gpioled_devp))
     
183.         {
     
184.                 ret = -ENOMEM;
     
185.                 goto fail;
     
186.         }
     
187.         gpioled_class = class_create(THIS_MODULE,"gpioled");
     
188.         for(i=0; i
189.         {
     
190.                 gpioled_setup(gpioled_devp + i, i);
     
191.         }
     
192.         writel(~(1<
193. fail:
     
194.         return ret;
     
195. }
     
196. 
     
197. static void __exit gpioled_exit(void)
     
198. {
     
199.         int i;
     
200.         for(i=0; i
201.         {
     
202.                 devnum = MKDEV(major,i);
     
203.                 device_destroy(gpioled_class,devnum);
     
204.                 printk("%s exit.n",(gpioled_devp+ i)->name);
     
205.                 cdev_del(&(gpioled_devp+i)->cdev);
     
206.                 unregister_chrdev_region(devnum,1);               
     
207.         }
     
208.         class_destroy(gpioled_class);
     
209.         kfree(gpioled_devp);
     
210. }
     
211. 
     
212. module_init(gpioled_init);
     
213. module_exit(gpioled_exit);
     
214. 
     
215. MODULE_AUTHOR("yang yongsheng");
     
216. MODULE_LICENSE("GPL v2");
     

复制代码

功能还有待完善，先贴上来吧。
有关的寄存器图如下：

看下效果图：

不错，感谢分享！

michael_llh 发表于 2016-11-6 16:31
不错，感谢分享！

谢谢支持，

这个叫做学以致用~

棒棒哒~~~

柠檬守护 发表于 2016-11-15 12:19
棒棒哒~~~

我还有很多不会呢，