Chinaunix首页 | 论坛 | 博客

我踏月色而来leader.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

LYZC11

  • 博客访问： 752048
  • 博文数量： 98
  • 博客积分： 4934
  • 博客等级： 上校
  • 技术积分： 1151
  • 用 户 组： 普通用户
  • 注册时间： 2009-06-12 19:55
文章分类

全部博文（98）

文章存档

2014年（1）

2013年（2）

2012年（4）

2011年（25）

2010年（33）

2009年（33）

我的朋友
最近访客
推荐博文
相关博文
android平台led开发之内核硬件驱动层

分类： 嵌入式

2012-09-27 14:25:56

手上有一个android开发平台,于是想在底层加个自己的硬件模块然后通过Android的HAL方式向上封装出底层驱动供JAVA APP调用。既然是刚上手,那就用led灯来做为先导开发走走流程吧,至少得把从内核到应用层的流程走通才行。
 
 
从底层到上层一共分成四个阶段。
1: 内核硬件驱动层
2: HAL(硬件抽象层)
3: 框架层(framework,包含JNI和实现硬件服务的JAVA接口)
4: JAVA应用层
 
 
 
一，首先是第一层,内核硬件驱动层
    在kernel\driver\下新建一个目录swt,在swt下再新建led文件夹,并新建swtled.c swtled.h,通过注册模块方式,实现ioctl,write,read接口。之后通过设备名给上层访问。
    swtled.c部分
   

点击(此处)折叠或打开

  1. #include <linux/kernel.h>
  2. #include <linux/sched.h>
  3. #include <linux/timer.h>
  4. #include <linux/init.h>
  5. #include <linux/module.h>
  6. #include <linux/uaccess.h>
  7. #include <linux/gpio.h>
  8. #include <linux/cdev.h>
  9. #include <linux/fs.h>
  10. #include <linux/device.h>
  11. #include <linux/miscdevice.h>
  12. #include <linux/watchdog.h>
  13. #include <linux/fs.h>

  15. #include <asm/io.h>
  16. #include <mach/gpio.h>
  17. #include <asm/uaccess.h>


  20. #define LED_ON _IO ('k',1)
  21. #define LED_OFF _IO ('k',2)


  24. struct light_dev
  25. {
  26.     struct cdev cdev;
  27.     
  28.     unsigned char value;
  29. };

  31. static struct light_dev *light_devp;
  32. static struct class * light_class = NULL;


  35. int light_major = 250;

  37. #if 0


  40. static ssize_t light_val_show(struct device* dev, struct device_attribute* attr, char* buf)
  41. {
  42.     return 0;
  43. }

  45. static ssize_t light_val_store(struct device* dev, struct device_attribute* attr, const char* buf, size_t count)
  46. {
  47.     return 0;
  48. }


  51. static DEVICE_ATTR(val, S_IRUGO | S_IWUSR, light_val_show, light_val_store);

  53. #endif

  55. void led_off(int arg)
  56. {
  57.     switch(arg)
  58.     {
  59.         case 1: gpio_set_value(RK29_PIN6_PB3,GPIO_LOW); //GPIO8
  60.         break;

  62.         case 2: gpio_set_value(RK29_PIN6_PC2,GPIO_LOW); //GPIO10
  63.         break;

  65.         default:
  66.         break;
  67.     }
  68. }

  70. void led_on(int arg)
  71. {
  72.     switch(arg)
  73.     {
  74.         case 1: gpio_set_value(RK29_PIN6_PB3,GPIO_HIGH);
  75.         break;

  77.         case 2: gpio_set_value(RK29_PIN6_PC2,GPIO_HIGH);
  78.         break;

  80.         default:
  81.         break;
  82.     }
  83. }


  86. int light_open(struct inode *inode, struct file *filp)
  87. {
  88.     struct light_dev *dev;

  90.     int ret = 0;

  92.     printk(KERN_ALERT"light_open()");
  93.     

  95.     dev = container_of(inode->i_cdev, struct light_dev, cdev);

  97.     filp->private_data = dev;

  99.     ret = gpio_request(RK29_PIN6_PB3, NULL);

  101.         if(ret != 0)
  102.         {
  103.             gpio_free(RK29_PIN6_PB3);
  105.         }
  106.         gpio_direction_output(RK29_PIN6_PB3, 0);

  108.         ret = gpio_request(RK29_PIN6_PC2, NULL);

  110.         if(ret != 0)
  111.         {
  112.             gpio_free(RK29_PIN6_PC2);
  114.         }
  115.         gpio_direction_output(RK29_PIN6_PC2, 0);



  119.     return 0;
  120. }

  122. int light_release(struct inode *inode, struct file *filp)
  123. {
  124.     printk(KERN_ALERT"light_release()");
  125.     
  126.     return 0;
  127. }



  131. ssize_t light_read(struct file *filp, char __user *buf, size_t count, loff_t*f_pos)
  132. {
  133.     struct light_dev *dev = filp->private_data;

  135.     printk(KERN_ALERT"light_read()");

  137.     if (copy_to_user(buf, &(dev->value), 1))
  138.     {
  139.         return -EFAULT;
  140.     }
  141.     
  142.     return 1;
  143. }

  145. ssize_t light_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
  146. {
  147.     struct light_dev *dev = filp->private_data;

  149.     printk(KERN_ALERT"light_write()");
  150.     
  151.     if (copy_from_user(&(dev->value), buf, 1))
  152.     {
  153.         return -EFAULT;
  154.     }
  155.     


  158.     if (dev->value == 1)
  159.         printk(KERN_ALERT"LED on");
  160.     else
  161.         printk(KERN_ALERT"LED off");
  162.     return 1;
  163. }


  166. int light_ioctl(struct inode    *inode, struct file *filp, unsigned int cmd, unsigned long arg)
  167. {
  168.     struct light_dev *dev = filp->private_data;

  170.     printk(KERN_ALERT"light_ioctl(cmd = %d)", cmd);
  171.     
  172.     switch (cmd)
  173.         {
  174.             case LED_ON:
  175.                 led_on(arg);
  176.                 break;
  177.             case LED_OFF:
  178.                 led_off(arg);
  179.                 break;
  180.             default: break;
  181.         }

  183.     
  184.     return 0;
  185. }

  187. struct file_operations light_fops =
  188. {
  189.     .owner = THIS_MODULE,
  190.     .read = light_read,
  191.     .write = light_write,
  192.     .ioctl = light_ioctl,
  193.     .open = light_open,
  194.     .release = light_release,
  195. };

  197. static int light_setup_cdev(struct light_dev *dev, int index)
  198. {
  199.     int err, devno = MKDEV(light_major, index);
  200.     cdev_init(&dev->cdev, &light_fops);
  201.     dev->cdev.owner = THIS_MODULE;
  202.     dev->cdev.ops = &light_fops;
  203.     dev->value = 0;
  204.     err = cdev_add(&dev->cdev, devno, 1);

  206.     return err;
  207. }



  211. int light_init(void)
  212. {
  213.     int result = 0;
  214.     
  215.     struct device * temp = NULL;    

  217.     dev_t dev = MKDEV(light_major, 0);
  218.         
  219.     printk(KERN_ALERT"light_init()");


  222.     
  223.     if (light_major) {
  224.         result = register_chrdev_region(dev, 1, "LED");
  225.     }
  226.     else {
  227.         result = alloc_chrdev_region(&dev, 0, 1, "LED");

  229.         light_major = MAJOR(dev);
  230.     }
  231.     
  232.     if (result < 0) {
  233.         goto failed;
  234.     }
  235.     

  237.     
  238.     light_devp = kmalloc(sizeof(struct light_dev), GFP_KERNEL);    
  239.     if (!light_devp){    
  240.         result = -ENOMEM;        
  241.         goto unregister;
  242.     }
  243.     
  244.     memset(light_devp, 0, sizeof(struct light_dev));
  245.     
  246.     result = light_setup_cdev(light_devp, 0);
  247.     if(result) {
  248.         goto cleanup;
  249.     }


  252.     
  253.     light_class = class_create(THIS_MODULE, "led");
  254.     if(IS_ERR(light_class)) {
  255.         printk(KERN_ALERT"Failed to create light class./n");
  256.         goto destroy_cdev;    
  257.     }        
  258.     

  260.     
  261.     temp = device_create(light_class, NULL, dev, "%s", "swtled");
  262.     if(IS_ERR(temp)) {    
  263.         printk(KERN_ALERT"Failed to create hello device.");
  264.         goto destroy_class;     
  265.     }

  267. #if 0

  269.     
  270.     result = device_create_file(temp, &dev_attr_val);
  271.     if(result < 0) {
  272.      printk(KERN_ALERT"Failed to create attribute val.");
  273.      goto destroy_device;
  274.     }

  276.     dev_set_drvdata(temp, light_devp);
  277. #endif    
  278.     

  280.     
  281.     return 0;

  283. destroy_device:
  284.     device_destroy(light_class, dev);
  285.   
  286. destroy_class:    
  287.     class_destroy(light_class);
  288.   
  289. destroy_cdev:
  290.     cdev_del(&(light_devp->cdev));

  292. cleanup:
  293.         kfree(light_devp);
  294.         
  295. unregister:

  297.     unregister_chrdev_region(dev, 1);
  298.     
  299. failed:

  301.     printk(KERN_ALERT"light_init failed.");
  302.     
  303.     
  304. return result;

  306. }


  309. void light_cleanup(void)
  310. {
  311.     printk(KERN_ALERT"light_cleanup()");


  314.     
  315.     if(light_class) {
  316.         device_destroy(light_class, MKDEV(light_major, 0));
  317.         class_destroy(light_class);
  318.     }
  319.   

  321.     if(light_devp) {
  322.         cdev_del(&light_devp->cdev);
  323.         kfree(light_devp);
  324.     }
  325.     
  326.     unregister_chrdev_region(MKDEV(light_major, 0), 1);
  327.     
  328. }

  330. module_init(light_init);
  331. module_exit(light_cleanup);


  334. MODULE_LICENSE("GPL");
  335. MODULE_DESCRIPTION("led driver");
  336. MODULE_ALIAS("led module");
led文件夹中Kconfig文件

点击(此处)折叠或打开

  1. config SWT_XXX_LED
  2.     bool "swt led"
  3.     default n
  4.     help
  5.      This compiles in support for the led of xxx.
led文件夹中MakeFile文件


点击(此处)折叠或打开

  1. obj-$(CONFIG_SWT_XXX_LED)+=swt_led.o
swtled文件中Kconfig文件

点击(此处)折叠或打开

  1. menu "swtled Drivers"

  3. source "drivers/swt/led/Kconfig"

  5. endmenu
swtled文件夹中MakeFile文件

点击(此处)折叠或打开

  1. obj-y += led/
接下来,就要修改kernel/driver下的MakeFile和Kconfig文件了,在分别其中添加一句
 
MakeFile文件

点击(此处)折叠或打开

  1. obj-y += swt/
Kconfig文件

点击(此处)折叠或打开

  1. source "drivers/swt/Kconfig"
保存所有之后,执行make
编译成功后，就可以在swt/led目录下看到swtled.o文件了，这时候编译出来的img已经包含了swtled驱动了





 
阅读(7861) | 评论(0) | 转发(1) |
0

上一篇：iptables配置nat表实现接入AP后IP跳转

下一篇：android平台led开发之硬件抽象层

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6