Linux驱动程序第一步（LED控制）

3114阅读　0评论2011-08-05　gfvvz
分类：LINUX

1.驱动程序
  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/init.h>
  4. #include <linux/fs.h>
  5. #include <linux/errno.h>
  6. #include <linux/cdev.h>
  7. #include <linux/types.h>
  8. #include <linux/device.h>
  9. #include <linux/mm.h>
  10. #include <linux/slab.h>
  11. #include <linux/sched.h>
  12. #include <linux/poll.h>
  13. #include <asm/uaccess.h>
  14. #include <asm/irq.h>
  15. #include <asm/io.h>
  16. #include <mach/map.h>
  17. #include <mach/regs-clock.h>
  18. #include <mach/regs-gpio.h>
  19. #include <mach/gpio-bank-k.h>
  20. #include <plat/gpio-cfg.h>

  22. #define DRIVER_DEBUG
  23. #define DEVICE_NAME        "mydriver"
  24. //#define DEVICE_MAJOR    252

  26. /* parameters */
  27. static int major;
  28. static int minor = 0;
  29. static int nr_devs = 1;            /* number of devices */

  31. struct class *my_class;
  32. struct mydriver_dev {
  33.     struct cdev cdev;        /* char device structure */
  34. }*mydriver_devp;            /* device structure pointer */

  36. /*
  37. * The open function of device driver.
  38. */
  39. static int mydriver_open(struct inode *inode, struct file *file)
  40. {
  41.     unsigned int led_tmp;

  43. #ifdef DRIVER_DEBUG
  44.     printk("\nIn the open function of driver!");
  45. #endif

  47.     //turn off all lights
  48.     led_tmp = readl(S3C64XX_GPKDAT);
  49.     led_tmp = (led_tmp | 0x000000f0);
  50.     writel(led_tmp, S3C64XX_GPKDAT);

  52.     return 0;
  53. }

  55.  static int mydriver_release(struct inode *inode, struct file *filp)
  56.  {
  57.     unsigned int led_tmp;

  59. #ifdef DRIVER_DEBUG
  60.     printk("In the release function of driver!\n");
  61. #endif
  62.     
  63.     //turn off all lights
  64.     led_tmp = readl(S3C64XX_GPKDAT);
  65.     led_tmp = (led_tmp | 0x000000f0);
  66.     writel(led_tmp, S3C64XX_GPKDAT);

  68.     return 0;
  69.  }

  71. /*
  72. * The read function of device driver. 
  73. */
  74. static int mydriver_read(struct file *filp, char __user *buff, size_t count, loff_t *offp)
  75. {
  76.     char led_state_read;

  78. #ifdef DRIVER_DEBUG    
  79.     printk("\nIn the read function of driver!");
  80. #endif

  82.     led_state_read = readl(S3C64XX_GPKDAT);
  83.     copy_to_user(buff, &led_state_read, 1);

  85.     return 1;
  86. }

  88. /*
  89. * The write function of device driver. 
  90. */
  91. static ssize_t mydriver_write(struct file *file, const char __user *buf, size_t count, loff_t * ppos)
  92. {
  93.     unsigned int led_tmp;    
  94.     char led_state_write;

  96. #ifdef DRIVER_DEBUG
  97.     printk("\nIn the write function of driver!");
  98. #endif

  100.     copy_from_user(&led_state_write, buf, 1);
  101.     if (led_state_write <= 0x0f) {
  102.         led_tmp = readl(S3C64XX_GPKDAT);
  103.         led_tmp &= (led_state_write << 4);    //GPK[7:4] is connected to LEDs
  104.         led_tmp |= (led_state_write << 4);
  105.         writel(led_tmp, S3C64XX_GPKDAT);
  106.     } else {
  107.         printk("ERR: Illegal Input!\n");
  108.         printk("Please input the data that not over 16.\n");
  109.     }

  111.     return 1;
  112. }

  114. /*
  115.  * The file operations for the device
  116.  */
  117. static struct file_operations mydriver_fops = {
  118. .owner = THIS_MODULE,
  119. .open = mydriver_open,
  120. .release = mydriver_release,
  121. .read = mydriver_read,     
  122. .write = mydriver_write
  123. };

  125. /*
  126.  * Set up a cdev entry.
  127.  */
  128. static void mydriver_setup_cdev(struct mydriver_dev *dev, int index)
  129. {
  130.     int err, devno;

  132.     devno= MKDEV(major, minor + index);

  134.     cdev_init(&dev->cdev, &mydriver_fops);
  135.     dev->cdev.owner = THIS_MODULE;
  136.     err = cdev_add (&dev->cdev, devno, 1);
  137.     if (err)
  138.         printk(KERN_NOTICE "Error %d adding mydriver%d", err, index);
  139. }

  141. /*
  142.  * Initialize the pipe devs; return how many we did.
  143.  */
  144. static int __init mydriver_init_module(void)
  145. {
  146.     int ret;
  147.     dev_t devno = MKDEV(major, minor);

      /* 注册设备 */
  1.     if (major) /* 静态申请主设备号 */
  2.         ret = register_chrdev_region(devno, nr_devs, DEVICE_NAME);
  3.     else { /* 动态分配主设备号 */
  4.         ret = alloc_chrdev_region(&devno, minor, nr_devs, DEVICE_NAME);
  5.         major = MAJOR(devno);
  6.     }
  7.     if (ret < 0) {
  8.         printk(KERN_WARNING "%s: can't get major %d\n", DEVICE_NAME, major);
  9.         return ret;
  10.     }
      
     /* 动态申请设备结构体的内存并清零 */
  1.     mydriver_devp = kzalloc(sizeof(struct mydriver_dev), GFP_KERNEL);
  2.     if (!mydriver_devp) {
  3.         ret = - ENOMEM;
  4.         goto fail_malloc;

  6.     }

     /* 初始化字符设备结构体 */
  1.     /* The following step must after kmalloc() and memset() */
  2.     mydriver_setup_cdev(mydriver_devp, 0);

     /* 自动创建设备文件 */
  1.     /* 1. create your own class under /sys
  2.     *  2. register your own device in sys
  3.     *     this will cause udev to create corresponding device node
  4.     */
  5.     my_class = class_create(THIS_MODULE, "my_class");
  6.     if (IS_ERR(my_class)) {
  7.         printk(DEVICE_NAME " failed in creating class./n");
  8.         return -1; 
  9.     }
  10.     device_create(my_class, NULL, MKDEV(major, minor), NULL, "mydriver""%d", 0);

  12.     printk(DEVICE_NAME "\tinitialized, major = %d, minor = %d.\n", major, minor);

  14.     return 0;

  16. fail_malloc:
  17.     unregister_chrdev_region(devno, 1);

  19.     return ret;
  20. }

  22. /*
  23.  * This is called by cleanup_module or on failure.
  24.  */
  25. static void __exit mydriver_exit_module(void)
  26. {
  27.     device_destroy(my_class, MKDEV(major, minor));
  28.     class_destroy(my_class);
  29.     cdev_del(&mydriver_devp->cdev);
  30.     kfree(mydriver_devp);
  31.     unregister_chrdev_region(MKDEV(major, minor), 1);    
  32.     printk(DEVICE_NAME "\texited!\n");
  33. }

  35. module_init(mydriver_init_module);
  36. module_exit(mydriver_exit_module);

  38. MODULE_AUTHOR("Jason Lu");
  39. MODULE_VERSION("0.1.0");
  40. MODULE_DESCRIPTION("Jason's blog: http://blog.chinaunix.net/space.php?uid=20746260");
  41. MODULE_LICENSE("Dual MPL/GPL");
2.应用程序
  1. #include
  2. #include
  3. #include
  4. #include
  5. #include
  6. #include

  8. int main()
  9. {
  10. int fd, i = 0;
  11. char led_read_buf = 0, led_write_buf = 0;
  13. printf("--------------------------------------------------------------\n");
  14. printf("--- This is the begining of the test program of my driver! ---\n");
  15. printf("--------------------------------------------------------------\n");
  16. sleep(1); //加入延时是为了打印信息和程序执行过程同步输出，下同
  18. /* 1. open the device driver */
  19. printf("1. open device driver:\n");
  20. fd = open("/dev/mydriver0", O_RDWR);
  21. if (fd < 0) {
  22. printf("Device open error!\n");
  23. exit(1);
  24. }
  25. sleep(1);

  27. /* 2. Read LED status */
  28. printf("2. Read LED status:\n");
  29. if (read(fd, &led_read_buf, 1) < 0) {
  30. printf("Read data error!\n");
  31. exit(1);
  32. }
  33. /* GPK[7:4] is connected to LEDs */
  34. printf("The status of GPK[7:0] is 0x%x.\n", led_read_buf);
  35. sleep(1);
  37. /* 3. Control LED lights */
  38. printf("3. Control LED lights:\n");
  39. while (i < 128) {
  40. led_write_buf = i % 16;
  41. write(fd, &led_write_buf, 1);
  42. sleep(1);
  43. i++;
  44. }

  46. /* 4. close device driver */
  47. close(fd);
  49. printf("---------------------------------------------------------\n");
  50. printf("--- This is the end of the test program of my driver! ---\n");
  51. printf("---------------------------------------------------------\n");

  53. return 0;
  54. }
3. 把驱动程序加入内核(One)
a.把上述驱动程序添加到/driver/char目录下；
b.把/driver/char目录下的Kconfig文件里，添加如下几行：
  1. config MY_DRIVER
  2. tristate "My driver for FriendlyARM Tiny6410 development boards"
  3. depends on MACH_MINI6410
  4. default m if MACH_MINI6410 //默认是内核模块
  5. help
  6. this is My driver for FriendlyARM Tiny6410 development boards
c.把/driver/char目录下的Makefile文件里，添加如下一行：
  1. obj-$(CONFIG_MY_DRIVER) += my_driver.o
d.cp config_mini6410_n43 .config
e.make menuconfig
f.在出现的配置界面里，输入D，找到Device Drivers，按Enter键进入子界面
g.在子配置界面里，两次输入C，找到Character devices，按Enter键进入子界面
h.查看是否有一行是 My driver for FriendlyARM Tiny6410 development boards
i.退出，make uImage
j.待生成uImage后，在内核工程主目录下输入：
  1. mkimage -A arm -O linux -T kernel -C none -a 0x50018000 -e 0x50018040 -n "Jason Linux" -d arch/arm/boot/zImage ./uImage
k.把内核通过SD卡烧入开发板
l.make modules  驱动程序如果没有错误的话，就会生成my_driver.ko
m.通过串口终端rz命令，传入my_driver.ko以及应用程序的可执行文件drivertest，把前者放到lib/modules/2.6.38-FriendlyARM/kernel/drivers/char/目录下
n.然后如下图操作：


4. 把驱动程序加入内核(Two)
   注：modules:下一行必须以TAB键开始，下同，不解释。
  2. DRIVER_NAME =my_led
  3. KERNELDIR =/home/source/friendlyarm/linux-2.6.38-jason/
  4. PWD :=$(shell pwd)
  5. INSTALLDIR =$(KERNELDIR)/drivers/char/

  7. CROSS_COMPILE =/home/source/friendlyarm/toolschain/4.5.1/bin/arm-linux-
  8. CC =$(CROSS_COMPILE)gcc

  10. obj-m :=$(DRIVER_NAME).o 

  12. modules:
  13. $(MAKE) -C $(KERNELDIR) M=$(PWD) modules

  15. modules_install:
  16. cp $(DRIVER_NAME).ko $(INSTALLDIR)

  18. clean:
  19. rm -rf *.o *~ core .depend .*.cmd *.mod.c .tmp_versions *.symvers *.order

  21. clean_all:
  22. rm -rf *.ko *.o *~ core .depend .*.cmd *.mod.c .tmp_versions *.symvers *.order

  24. .PHONY: modules modules_install clean

上一篇：Ubuntu下，APUE2源码编译方法及单个源码编译的实现
下一篇：基于输入子系统的GPIO按键的配置