devbox
盐析白兔
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Linux——驱动：字符设备驱动框架

作者：盐析白兔 | 2024-03-02 12:25:07

赞

踩

字符设备驱动框架

1.字符设备理论源码分析

字符设备是 Linux 驱动中最基本的一类设备驱动，字符设备就是一个一个字节，按照字节流进行读写操作的设备，读写数据是分先后顺序的。比如我们最常见的点灯、按键、 IIC、 SPI，LCD 等等都是字符设备，这些设备的驱动就叫做字符设备驱动。在用户空间控制一个字符设备的流程如图所示。

 例如在用户空间中调用open，打开一个字符设备，执行流程如下：最终会执行chrdev中的ops对应的open函数。

 1.1 字符设备的注册

字符设备相关的结构体：

  1. static struct char_device_struct {
  2.  struct char_device_struct *next;
  3.  unsigned int major;
  4.  unsigned int baseminor;
  5.  int minorct;
  6.  char name[64];
  7.  struct cdev *cdev;        /* will die */
  8. } *chrdevs[CHRDEV_MAJOR_HASH_SIZE];
  9.  
  10. #define CHRDEV_MAJOR_HASH_SIZE 255
  11. struct cdev {
  12.  struct kobject kobj;
  13.  struct module *owner;
  14.  const struct file_operations *ops;
  15.  struct list_head list;
  16.  dev_t dev;
  17.  unsigned int count;
  18. };

其中chrdevs为一个全局数组，且：

#define CHRDEV_MAJOR_HASH_SIZE	255

1.1.1旧版本：申请设备号

旧版本的注册函数为：

  1. static inline int register_chrdev(unsigned int major, const char *name,
  2. 				  const struct file_operations *fops)
  3.  
  4. static inline int register_chrdev(unsigned int major, const char *name,
  5. 				  const struct file_operations *fops)
  6. {
  7. 	return __register_chrdev(major, 0, 256, name, fops);
  8. }

通过调用__register_chrdev(major, 0, 256, name, fops)来进行注册：

  1. int __register_chrdev(unsigned int major, unsigned int baseminor,
  2. 		      unsigned int count, const char *name,
  3. 		      const struct file_operations *fops)
  4. {
  5. 	struct char_device_struct *cd;
  6. 	struct cdev *cdev;
  7. 	int err = -ENOMEM;
  8.  
  9. 	cd = __register_chrdev_region(major, baseminor, count, name);
  10. 	if (IS_ERR(cd))
  11. 		return PTR_ERR(cd);
  12.  
  13. 	cdev = cdev_alloc();
  14. 	if (!cdev)
  15. 		goto out2;
  16.  
  17. 	cdev->owner = fops->owner;
  18. 	cdev->ops = fops;
  19. 	kobject_set_name(&cdev->kobj, "%s", name);
  20.  
  21. 	err = cdev_add(cdev, MKDEV(cd->major, baseminor), count);
  22. 	if (err)
  23. 		goto out;
  24.  
  25. 	cd->cdev = cdev;
  26.  
  27. 	return major ? 0 : cd->major;
  28. out:
  29. 	kobject_put(&cdev->kobj);
  30. out2:
  31. 	kfree(__unregister_chrdev_region(cd->major, baseminor, count));
  32. 	return err;
  33. }
  1. static struct char_device_struct *
  2. __register_chrdev_region(unsigned int major, unsigned int baseminor,
  3. 			   int minorct, const char *name)
  4. {
  5. 	struct char_device_struct *cd, **cp;
  6. 	int ret = 0;
  7. 	int i;
  8.  
  9. 	cd = kzalloc(sizeof(struct char_device_struct), GFP_KERNEL);
  10. 	if (cd == NULL)
  11. 		return ERR_PTR(-ENOMEM);
  12.  
  13. 	mutex_lock(&chrdevs_lock);
  14.  
  15. 	/* temporary */
  16. 	if (major == 0) { //如果没有指定主设备号
  17. 		for (i = ARRAY_SIZE(chrdevs)-1; i > 0; i--) {
  18. 			if (chrdevs[i] == NULL)
  19. 				break;
  20. 		}
  21.  
  22. 		if (i == 0) {
  23. 			ret = -EBUSY;
  24. 			goto out;
  25. 		}
  26. 		major = i;
  27. 	}
  28.  
  29. 	cd->major = major;
  30. 	cd->baseminor = baseminor;
  31. 	cd->minorct = minorct;
  32. 	strlcpy(cd->name, name, sizeof(cd->name));
  33.  
  34. 	i = major_to_index(major);
  35.  
  36. 	for (cp = &chrdevs[i]; *cp; cp = &(*cp)->next) //寻找空的子设备位置
  37. 		if ((*cp)->major > major ||
  38. 		    ((*cp)->major == major &&
  39. 		     (((*cp)->baseminor >= baseminor) ||
  40. 		      ((*cp)->baseminor + (*cp)->minorct > baseminor))))
  41. 			break;
  42.  
  43. 	/* Check for overlapping minor ranges.  */
  44. 	if (*cp && (*cp)->major == major) {
  45. 		int old_min = (*cp)->baseminor;
  46. 		int old_max = (*cp)->baseminor + (*cp)->minorct - 1;
  47. 		int new_min = baseminor;
  48. 		int new_max = baseminor + minorct - 1;
  49.  
  50. 		/* New driver overlaps from the left.  */
  51. 		if (new_max >= old_min && new_max <= old_max) {
  52. 			ret = -EBUSY;
  53. 			goto out;
  54. 		}
  55.  
  56. 		/* New driver overlaps from the right.  */
  57. 		if (new_min <= old_max && new_min >= old_min) {
  58. 			ret = -EBUSY;
  59. 			goto out;
  60. 		}
  61. 	}
  62.  
  63. 	cd->next = *cp;
  64. 	*cp = cd;
  65. 	mutex_unlock(&chrdevs_lock);
  66. 	return cd;
  67. out:
  68. 	mutex_unlock(&chrdevs_lock);
  69. 	kfree(cd);
  70. 	return ERR_PTR(ret);
  71. }

1.1.2新版本：申请设备号

（1）提前指定了设备号：可以通过MKDEV（major）获取dev_t。

  1. int register_chrdev_region(dev_t from, unsigned count, const char *name)
  2. {
  3. 	struct char_device_struct *cd;
  4. 	dev_t to = from + count;
  5. 	dev_t n, next;
  6.  
  7. 	for (n = from; n < to; n = next) {
  8. 		next = MKDEV(MAJOR(n)+1, 0);
  9. 		if (next > to)
  10. 			next = to;
  11. 		cd = __register_chrdev_region(MAJOR(n), MINOR(n),
  12. 			       next - n, name);
  13. 		if (IS_ERR(cd))
  14. 			goto fail;
  15. 	}
  16. 	return 0;
  17. fail:
  18. 	to = n;
  19. 	for (n = from; n < to; n = next) {
  20. 		next = MKDEV(MAJOR(n)+1, 0);
  21. 		kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
  22. 	}
  23. 	return PTR_ERR(cd);
  24. }

（2）没有指定主设备号，由系统动态分配：

  1. int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,
  2. 			const char *name)
  3. {
  4. 	struct char_device_struct *cd;
  5. 	cd = __register_chrdev_region(0, baseminor, count, name);
  6. 	if (IS_ERR(cd))
  7. 		return PTR_ERR(cd);
  8. 	*dev = MKDEV(cd->major, cd->baseminor);
  9. 	return 0;
  10. }

（3）注销字符设备

  1. void unregister_chrdev_region(dev_t from, unsigned count)
  2. {
  3. 	dev_t to = from + count;
  4. 	dev_t n, next;
  5.  
  6. 	for (n = from; n < to; n = next) {
  7. 		next = MKDEV(MAJOR(n)+1, 0);
  8. 		if (next > to)
  9. 			next = to;
  10. 		kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
  11. 	}
  12. }

区别：

1.1.3 字符设备初始化

调用cdev_init()函数来把cdev与ops进行绑定：

  1. void cdev_init(struct cdev *cdev, const struct file_operations *fops)
  2. {
  3. 	memset(cdev, 0, sizeof *cdev);
  4. 	INIT_LIST_HEAD(&cdev->list);
  5. 	kobject_init(&cdev->kobj, &ktype_cdev_default);
  6. 	cdev->ops = fops;
  7. }

1.1.4 添加字符设备

通过调用cdev_add将申请到的cdev添加到与之对应的设备号下：

  1. int cdev_add(struct cdev *p, dev_t dev, unsigned count)
  2. {
  3. 	int error;
  4.  
  5. 	p->dev = dev;
  6. 	p->count = count;
  7.  
  8. 	error = kobj_map(cdev_map, dev, count, NULL,
  9. 			 exact_match, exact_lock, p);
  10. 	if (error)
  11. 		return error;
  12.  
  13. 	kobject_get(p->kobj.parent);
  14.  
  15. 	return 0;
  16. }

注销该设备的适合，需要调用cdev_del将其删掉：

  1. void cdev_del(struct cdev *p)
  2. {
  3. 	cdev_unmap(p->dev, p->count);
  4. 	kobject_put(&p->kobj);
  5. }

1.2 调用modprobe指令后自动创建设备

1.2.1 创建类class

通过调用class_create()函数进行创建类，在sys/class/下创建一个文件，并且通过udev的uevent机制通知有设备添加进来。

  1. #define class_create(owner, name)		\
  2. ({						\
  3. 	static struct lock_class_key __key;	\
  4. 	__class_create(owner, name, &__key);	\
  5. })
  1. struct class *__class_create(struct module *owner, const char *name,
  2. 			     struct lock_class_key *key)
  3. {
  4. 	struct class *cls;
  5. 	int retval;
  6.  
  7. 	cls = kzalloc(sizeof(*cls), GFP_KERNEL);
  8. 	if (!cls) {
  9. 		retval = -ENOMEM;
  10. 		goto error;
  11. 	}
  12.  
  13. 	cls->name = name;
  14. 	cls->owner = owner;
  15. 	cls->class_release = class_create_release;
  16.  
  17. 	retval = __class_register(cls, key);
  18. 	if (retval)
  19. 		goto error;
  20.  
  21. 	return cls;
  22.  
  23. error:
  24. 	kfree(cls);
  25. 	return ERR_PTR(retval);
  26. }
  1. int __class_register(struct class *cls, struct lock_class_key *key)
  2. {
  3. 	struct subsys_private *cp;
  4. 	int error;
  5.  
  6. 	pr_debug("device class '%s': registering\n", cls->name);
  7.  
  8. 	cp = kzalloc(sizeof(*cp), GFP_KERNEL);//类同bus，分配一个私有数据
  9. 	if (!cp)
  10. 		return -ENOMEM;
  11. 	klist_init(&cp->klist_devices, klist_class_dev_get, klist_class_dev_put);//初始化class 链表
  12. 	INIT_LIST_HEAD(&cp->interfaces);
  13. 	kset_init(&cp->glue_dirs);
  14. 	__mutex_init(&cp->mutex, "subsys mutex", key);
  15. 	error = kobject_set_name(&cp->subsys.kobj, "%s", cls->name);
  16. 	if (error) {
  17. 		kfree(cp);
  18. 		return error;
  19. 	}
  20.  
  21. 	/* set the default /sys/dev directory for devices of this class */
  22. 	if (!cls->dev_kobj)
  23. 		cls->dev_kobj = sysfs_dev_char_kobj;
  24.  
  25. #if defined(CONFIG_BLOCK)
  26. 	/* let the block class directory show up in the root of sysfs */
  27. 	if (!sysfs_deprecated || cls != &block_class)
  28. 		cp->subsys.kobj.kset = class_kset;
  29. #else
  30. 	cp->subsys.kobj.kset = class_kset;
  31. #endif
  32. 	cp->subsys.kobj.ktype = &class_ktype;
  33. 	cp->class = cls;
  34. 	cls->p = cp;
  35. 	
  36. 	//在/sys/class/下面创建一个目录,同时发送一个uenent时间给上层
  37. 	error = kset_register(&cp->subsys);
  38. 	if (error) {
  39. 		kfree(cp);
  40. 		return error;
  41. 	}
  42. 	error = add_class_attrs(class_get(cls));
  43. 	class_put(cls);
  44. 	return error;
  45. }
  1. int kset_register(struct kset *k)
  2. {
  3. 	int err;
  4.  
  5. 	if (!k)
  6. 		return -EINVAL;
  7. 	//初始化kset
  8. 	kset_init(k);
  9. 	//在sysfs中建立目录
  10. 	err = kobject_add_internal(&k->kobj);
  11. 	if (err)
  12. 		return err;
  13. 	// 向用户空间发送 KOBJ_ADD事件。
  14. 	kobject_uevent(&k->kobj, KOBJ_ADD);
  15. 	return 0;
  16. }

当注销设备时，需要调用class_destory()函数对class进行摧毁：

  1. int kset_register(struct kset *k)
  2. {
  3. 	int err;
  4.  
  5. 	if (!k)
  6. 		return -EINVAL;
  7. 	//初始化kset
  8. 	kset_init(k);
  9. 	//在sysfs中建立目录
  10. 	err = kobject_add_internal(&k->kobj);
  11. 	if (err)
  12. 		return err;
  13. 	// 向用户空间发送 KOBJ_ADD事件。
  14. 	kobject_uevent(&k->kobj, KOBJ_ADD);
  15. 	return 0;
  16. }

1.2.2 创建设备

一旦创建好了这个class，再调用device_create(…)函数来在/dev目录下创建相应的设备节点。这样，加载模块的时候，用户空间中的udev会自动响应device_create(…)函数，去/sysfs下寻找对应的类从而创建设备节点。

  1. /* 5、创建设备 */
  2. newchrled.device = device_create(newchrled.class, NULL, newchrled.devid, NULL, NEWCHRLED_NAME);
  3. struct device *device_create(struct class *class, struct device *parent,
  4. 			     dev_t devt, void *drvdata, const char *fmt, ...)
  5. {
  6. 	va_list vargs;
  7. 	struct device *dev;
  8.  
  9. 	va_start(vargs, fmt);
  10. 	dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);
  11. 	va_end(vargs);
  12. 	return dev;
  13. }
  14. struct device *device_create_vargs(struct class *class, struct device *parent,
  15. 				   dev_t devt, void *drvdata, const char *fmt,
  16. 				   va_list args)
  17. {
  18. 	return device_create_groups_vargs(class, parent, devt, drvdata, NULL,
  19. 					  fmt, args);
  20. }
  1. static struct device *
  2. device_create_groups_vargs(struct class *class, struct device *parent,
  3. 			   dev_t devt, void *drvdata,
  4. 			   const struct attribute_group **groups,
  5. 			   const char *fmt, va_list args)
  6. {
  7. 	struct device *dev = NULL;
  8. 	int retval = -ENODEV;
  9.  
  10. 	if (class == NULL || IS_ERR(class))
  11. 		goto error;
  12.  
  13. 	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
  14. 	if (!dev) {
  15. 		retval = -ENOMEM;
  16. 		goto error;
  17. 	}
  18.  
  19. 	//初始化dev
  20. 	device_initialize(dev);
  21. 	dev->devt = devt;
  22. 	dev->class = class;
  23. 	dev->parent = parent;
  24. 	dev->groups = groups;
  25. 	dev->release = device_create_release;
  26. 	dev_set_drvdata(dev, drvdata);
  27.  
  28. 	//设置kobject的名字
  29. 	retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
  30. 	if (retval)
  31. 		goto error;
  32.  
  33. 	retval = device_add(dev); //添加设备
  34. 	if (retval)
  35. 		goto error;
  36.  
  37. 	return dev;
  38.  
  39. error:
  40. 	put_device(dev);
  41. 	return ERR_PTR(retval);
  42. }
  1. int device_add(struct device *dev)
  2. {
  3. 	struct device *parent = NULL;
  4. 	struct kobject *kobj;
  5. 	struct class_interface *class_intf;
  6. 	int error = -EINVAL;
  7.  
  8. 	dev = get_device(dev); //增加设备的引用计数dev->kobj->kref
  9. 	if (!dev)
  10. 		goto done;
  11.  
  12. 	if (!dev->p) {
  13. 		//私有数据没有的话，申请并初始化：是连接bus，parent，对应驱动等重要连接点
  14. 		error = device_private_init(dev);
  15. 		if (error)
  16. 			goto done;
  17. 	}
  18.  
  19. 	/*
  20. 	 * for statically allocated devices, which should all be converted
  21. 	 * some day, we need to initialize the name. We prevent reading back
  22. 	 * the name, and force the use of dev_name()
  23. 	 */
  24. 	if (dev->init_name) {
  25. 		//用dev的init_name初始化dev->kobject->name，实际是目录名
  26. 		dev_set_name(dev, "%s", dev->init_name);
  27. 		dev->init_name = NULL;
  28. 	}
  29.  
  30. 	/* subsystems can specify simple device enumeration */
  31. 	//dev的init_name不存在且dev->kobject->name也不存在，则用bus的dev_name和dev_id来设置目录名
  32. 	if (!dev_name(dev) && dev->bus && dev->bus->dev_name)
  33. 		dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id);
  34.  
  35. 	if (!dev_name(dev)) { //如果上面几个步骤都还没找到可设的目录名，则失败返回，设备必须要放在某个目录下
  36. 		error = -EINVAL;
  37. 		goto name_error;
  38. 	}
  39.  
  40. 	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
  41.  
  42. 	parent = get_device(dev->parent); //父节点引用计数加1
  43. 	kobj = get_device_parent(dev, parent); //拿到父节点
  44. 	//拿到父节点赋值给本dev->kobj.parent，确定设备父子关系，也确定了sysfs中的目录关系
  45. 	if (kobj)
  46. 		dev->kobj.parent = kobj;
  47.  
  48. 	/* use parent numa_node */
  49. 	//设置该设备节点为-1
  50. 	if (parent)
  51. 		set_dev_node(dev, dev_to_node(parent));
  52.  
  53. 	/* first, register with generic layer. */
  54. 	/* we require the name to be set before, and pass NULL */
  55. 	//把内嵌的kobject注册到设备模型中，将设备加入到kobject模型中，创建sys项目目录，目录名字为kobj->name
  56. 	error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);
  57. 	if (error)
  58. 		goto Error;
  59.  
  60. 	/* notify platform of device entry */
  61. 	if (platform_notify)
  62. 		platform_notify(dev);
  63. 	/*创建sys目录下设备的uevent属性文件，通过它可以查看设备的uevent事件,主要是在/sys/devices/.../中添加dev的uevent属性文件*/
  64. 	error = device_create_file(dev, &dev_attr_uevent);
  65. 	if (error)
  66. 		goto attrError;
  67. 	/*实际创建的kobject都是在device下面,其他class,bus之类的里面的具体设备都是device目录下设备的符号链接,这里是在class下创建符号链接 */
  68. 	error = device_add_class_symlinks(dev);
  69. 	if (error)
  70. 		goto SymlinkError;
  71. 	error = device_add_attrs(dev);//创建sys目录下设备其他属性文件(添加设备属性文件)
  72. 	if (error)
  73. 		goto AttrsError;
  74. 	error = bus_add_device(dev);//添加设备的总线属性，将设备加入到管理它的bus总线的设备连表上，创建subsystem链接文件，链接class下的具体的子系统文件夹 将设备添加到其总线的设备列表中。
  75. 	if (error)
  76. 		goto BusError;
  77. 	error = dpm_sysfs_add(dev);//把设备增加到sysfs电源管理power目录（组）下,如果该设备设置电源管理相关的内容
  78. 	if (error)
  79. 		goto DPMError;
  80. 	device_pm_add(dev);//设备添加到电源管理相关的设备列表中
  81.  
  82. 	//主设备号存在，则产生dev属性，在/dev目录下产生设备节点文件
  83. 	if (MAJOR(dev->devt)) {
  84. 		/*创建sys目录下设备的设备号属性，即major和minor /主要是在sys/devices/...中添加dev属性文件*/
  85. 		error = device_create_file(dev, &dev_attr_dev);
  86. 		if (error)
  87. 			goto DevAttrError;
  88. 		/*在/sys/dev/char/或者/sys/dev/block/创建devt的属性的连接文件,形如10:45,由主设备号和次设备号构成,指向/sys/devices/.../的具体设备目录*/
  89. 		error = device_create_sys_dev_entry(dev);//该链接文件只具备读属性，显示主设备号：次设备号，如10:45,用户空间udev响应uevent事件时，将根据设备号在/dev下创建节点文件
  90. 		if (error)
  91. 			goto SysEntryError;
  92.  
  93. 		devtmpfs_create_node(dev);
  94. 	}
  95.  
  96. 	/* Notify clients of device addition.  This call must come
  97. 	 * after dpm_sysfs_add() and before kobject_uevent().
  98. 	 */
  99. 	if (dev->bus)//通知客户端,有新设备加入
  100. 		blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
  101. 					     BUS_NOTIFY_ADD_DEVICE, dev);
  102. 	/*产生一个内核uevent事件（这里是有设备加入），可以是helper,也可是通过netlink机制和用户空间通信该事件可以被内核以及应用层捕获，属于linux设备模型中热插拔机制*/
  103. 	kobject_uevent(&dev->kobj, KOBJ_ADD);
  104. 	//给设备探测寻找相对应的驱动，在bus上找dev对应的drv,主要执行__device_attach,主要进行match,sys_add,执行probe函数和绑定等操作
  105. 	bus_probe_device(dev);
  106. 	if (parent)
  107. 		klist_add_tail(&dev->p->knode_parent,//添加新设备到父设备的子列表中
  108. 			       &parent->p->klist_children);
  109.  
  110. 	if (dev->class) {//如果改dev有所属类，则将dev的添加到类的设备列表里面
  111. 		mutex_lock(&dev->class->p->mutex);//要使用class的互斥锁
  112. 		/* tie the class to the device */
  113. 		klist_add_tail(&dev->knode_class,//dev添加到class的klist_device链表（对driver也有klist_driver链表）
  114. 			       &dev->class->p->klist_devices);
  115.  
  116. 		/* notify any interfaces that the device is here */
  117. 		/*通知有新设备加入,执行该dev的class_intf->add_dev(),好处是只有设备匹配注册成功了，才进行其它的注册工作(如字符设备的注册，生成/dev/***节点文件)以及部分初始化工作。*/		   
  118. 		list_for_each_entry(class_intf,
  119. 				    &dev->class->p->interfaces, node)
  120. 			if (class_intf->add_dev)
  121. 				class_intf->add_dev(dev, class_intf);
  122. 		mutex_unlock(&dev->class->p->mutex);
  123. 	}
  124. done:
  125. 	put_device(dev);
  126. 	return error;
  127.  SysEntryError:
  128. 	if (MAJOR(dev->devt))
  129. 		device_remove_file(dev, &dev_attr_dev);
  130.  DevAttrError:
  131. 	device_pm_remove(dev);
  132. 	dpm_sysfs_remove(dev);
  133.  DPMError:
  134. 	bus_remove_device(dev);
  135.  BusError:
  136. 	device_remove_attrs(dev);
  137.  AttrsError:
  138. 	device_remove_class_symlinks(dev);
  139.  SymlinkError:
  140. 	device_remove_file(dev, &dev_attr_uevent);
  141.  attrError:
  142. 	kobject_uevent(&dev->kobj, KOBJ_REMOVE);
  143. 	kobject_del(&dev->kobj);
  144.  Error:
  145. 	cleanup_device_parent(dev);
  146. 	put_device(parent);
  147. name_error:
  148. 	kfree(dev->p);
  149. 	dev->p = NULL;
  150. 	goto done;
  151. }

同样地，在注销字符设备的适合，需要调用device_destroy()函数进行设备注销：

  1. void device_destroy(struct class *class, dev_t devt)
  2. {
  3. 	struct device *dev;
  4.  
  5. 	dev = class_find_device(class, NULL, &devt, __match_devt);
  6. 	if (dev) {
  7. 		put_device(dev);
  8. 		device_unregister(dev);
  9. 	}
  10. }

3.字符设备实践

  1. #include <linux/types.h>
  2. #include <linux/kernel.h>
  3. #include <linux/delay.h>
  4. #include <linux/ide.h>
  5. #include <linux/init.h>
  6. #include <linux/module.h>
  7. #include <linux/errno.h>
  8. #include <linux/gpio.h>
  9. #include <linux/cdev.h>
  10. #include <linux/device.h>
  11.  
  12. #include <asm/mach/map.h>
  13. #include <asm/uaccess.h>
  14. #include <asm/io.h>
  15.  
  16.  
  17. #define NEWCHRLED_CNT			1		  	/* 设备号个数 */
  18. #define NEWCHRLED_NAME			"newchrled"	/* 名字 */
  19. #define LEDOFF 					0			/* 关灯 */
  20. #define LEDON 					1			/* 开灯 */
  21.  
  22. /* 寄存器物理地址 */
  23. #define CCM_CCGR1_BASE				(0X020C406C)	
  24. #define SW_MUX_GPIO1_IO03_BASE		(0X020E0068)
  25. #define SW_PAD_GPIO1_IO03_BASE		(0X020E02F4)
  26. #define GPIO1_DR_BASE				(0X0209C000)
  27. #define GPIO1_GDIR_BASE				(0X0209C004)
  28.  
  29. /* 映射后的寄存器虚拟地址指针 */
  30. static void __iomem *IMX6U_CCM_CCGR1;
  31. static void __iomem *SW_MUX_GPIO1_IO03;
  32. static void __iomem *SW_PAD_GPIO1_IO03;
  33. static void __iomem *GPIO1_DR;
  34. static void __iomem *GPIO1_GDIR;
  35.  
  36. /* newchrled设备结构体 */
  37. struct newchrled_dev{
  38. 	dev_t devid;			/* 设备号 	 */
  39. 	struct cdev cdev;		/* cdev 	*/
  40. 	struct class *class;		/* 类 		*/
  41. 	struct device *device;	/* 设备 	 */
  42. 	int major;				/* 主设备号	  */
  43. 	int minor;				/* 次设备号   */
  44. };
  45.  
  46. struct newchrled_dev newchrled;	/* led设备 */
  47.  
  48. /*
  49.  * @description		: LED打开/关闭
  50.  * @param - sta 	: LEDON(0) 打开LED，LEDOFF(1) 关闭LED
  51.  * @return 			: 无
  52.  */
  53. void led_switch(u8 sta)
  54. {
  55. 	u32 val = 0;
  56. 	if(sta == LEDON) {
  57. 		val = readl(GPIO1_DR);
  58. 		val &= ~(1 << 3);	
  59. 		writel(val, GPIO1_DR);
  60. 	}else if(sta == LEDOFF) {
  61. 		val = readl(GPIO1_DR);
  62. 		val|= (1 << 3);	
  63. 		writel(val, GPIO1_DR);
  64. 	}	
  65. }
  66.  
  67. /*
  68.  * @description		: 打开设备
  69.  * @param - inode 	: 传递给驱动的inode
  70.  * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
  71.  * 					  一般在open的时候将private_data指向设备结构体。
  72.  * @return 			: 0 成功;其他 失败
  73.  */
  74. static int led_open(struct inode *inode, struct file *filp)
  75. {
  76. 	filp->private_data = &newchrled; /* 设置私有数据 */
  77. 	return 0;
  78. }
  79.  
  80. /*
  81.  * @description		: 从设备读取数据 
  82.  * @param - filp 	: 要打开的设备文件(文件描述符)
  83.  * @param - buf 	: 返回给用户空间的数据缓冲区
  84.  * @param - cnt 	: 要读取的数据长度
  85.  * @param - offt 	: 相对于文件首地址的偏移
  86.  * @return 			: 读取的字节数，如果为负值，表示读取失败
  87.  */
  88. static ssize_t led_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
  89. {
  90. 	return 0;
  91. }
  92.  
  93. /*
  94.  * @description		: 向设备写数据 
  95.  * @param - filp 	: 设备文件，表示打开的文件描述符
  96.  * @param - buf 	: 要写给设备写入的数据
  97.  * @param - cnt 	: 要写入的数据长度
  98.  * @param - offt 	: 相对于文件首地址的偏移
  99.  * @return 			: 写入的字节数，如果为负值，表示写入失败
  100.  */
  101. static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
  102. {
  103. 	int retvalue;
  104. 	unsigned char databuf[1];
  105. 	unsigned char ledstat;
  106.  
  107. 	retvalue = copy_from_user(databuf, buf, cnt);
  108. 	if(retvalue < 0) {
  109. 		printk("kernel write failed!\r\n");
  110. 		return -EFAULT;
  111. 	}
  112.  
  113. 	ledstat = databuf[0];		/* 获取状态值 */
  114.  
  115. 	if(ledstat == LEDON) {	
  116. 		led_switch(LEDON);		/* 打开LED灯 */
  117. 	} else if(ledstat == LEDOFF) {
  118. 		led_switch(LEDOFF);	/* 关闭LED灯 */
  119. 	}
  120. 	return 0;
  121. }
  122.  
  123. /*
  124.  * @description		: 关闭/释放设备
  125.  * @param - filp 	: 要关闭的设备文件(文件描述符)
  126.  * @return 			: 0 成功;其他 失败
  127.  */
  128. static int led_release(struct inode *inode, struct file *filp)
  129. {
  130. 	return 0;
  131. }
  132.  
  133. /* 设备操作函数 */
  134. static struct file_operations newchrled_fops = {
  135. 	.owner = THIS_MODULE,
  136. 	.open = led_open,
  137. 	.read = led_read,
  138. 	.write = led_write,
  139. 	.release = 	led_release,
  140. };
  141.  
  142. /*
  143.  * @description	: 驱动出口函数
  144.  * @param 		: 无
  145.  * @return 		: 无
  146.  */
  147. static int __init led_init(void)
  148. {
  149. 	u32 val = 0;
  150.  
  151. 	/* 初始化LED */
  152. 	/* 1、寄存器地址映射 */
  153.   	IMX6U_CCM_CCGR1 = ioremap(CCM_CCGR1_BASE, 4);
  154. 	SW_MUX_GPIO1_IO03 = ioremap(SW_MUX_GPIO1_IO03_BASE, 4);
  155.   	SW_PAD_GPIO1_IO03 = ioremap(SW_PAD_GPIO1_IO03_BASE, 4);
  156. 	GPIO1_DR = ioremap(GPIO1_DR_BASE, 4);
  157. 	GPIO1_GDIR = ioremap(GPIO1_GDIR_BASE, 4);
  158.  
  159. 	/* 2、使能GPIO1时钟 */
  160. 	val = readl(IMX6U_CCM_CCGR1);
  161. 	val &= ~(3 << 26);	/* 清除以前的设置 */
  162. 	val |= (3 << 26);	/* 设置新值 */
  163. 	writel(val, IMX6U_CCM_CCGR1);
  164.  
  165. 	/* 3、设置GPIO1_IO03的复用功能，将其复用为
  166. 	 *    GPIO1_IO03，最后设置IO属性。
  167. 	 */
  168. 	writel(5, SW_MUX_GPIO1_IO03);
  169. 	
  170. 	/*寄存器SW_PAD_GPIO1_IO03设置IO属性
  171. 	 *bit 16:0 HYS关闭
  172. 	 *bit [15:14]: 00 默认下拉
  173.      *bit [13]: 0 kepper功能
  174.      *bit [12]: 1 pull/keeper使能
  175.      *bit [11]: 0 关闭开路输出
  176.      *bit [7:6]: 10 速度100Mhz
  177.      *bit [5:3]: 110 R0/6驱动能力
  178.      *bit [0]: 0 低转换率
  179. 	 */
  180. 	writel(0x10B0, SW_PAD_GPIO1_IO03);
  181.  
  182. 	/* 4、设置GPIO1_IO03为输出功能 */
  183. 	val = readl(GPIO1_GDIR);
  184. 	val &= ~(1 << 3);	/* 清除以前的设置 */
  185. 	val |= (1 << 3);	/* 设置为输出 */
  186. 	writel(val, GPIO1_GDIR);
  187.  
  188. 	/* 5、默认关闭LED */
  189. 	val = readl(GPIO1_DR);
  190. 	val |= (1 << 3);	
  191. 	writel(val, GPIO1_DR);
  192.  
  193. 	/* 注册字符设备驱动 */
  194. 	/* 1、创建设备号 */
  195. 	if (newchrled.major) {		/*  定义了设备号 */
  196. 		newchrled.devid = MKDEV(newchrled.major, 0);
  197. 		register_chrdev_region(newchrled.devid, NEWCHRLED_CNT, NEWCHRLED_NAME);
  198. 	} else {						/* 没有定义设备号 */
  199. 		alloc_chrdev_region(&newchrled.devid, 0, NEWCHRLED_CNT, NEWCHRLED_NAME);	/* 申请设备号 */
  200. 		newchrled.major = MAJOR(newchrled.devid);	/* 获取分配号的主设备号 */
  201. 		newchrled.minor = MINOR(newchrled.devid);	/* 获取分配号的次设备号 */
  202. 	}
  203. 	printk("newcheled major=%d,minor=%d\r\n",newchrled.major, newchrled.minor);	
  204. 	
  205. 	/* 2、初始化cdev */
  206. 	newchrled.cdev.owner = THIS_MODULE;
  207. 	cdev_init(&newchrled.cdev, &newchrled_fops);
  208. 	
  209. 	/* 3、添加一个cdev */
  210. 	cdev_add(&newchrled.cdev, newchrled.devid, NEWCHRLED_CNT);
  211.  
  212. 	/* 4、创建类 */
  213. 	newchrled.class = class_create(THIS_MODULE, NEWCHRLED_NAME);
  214. 	if (IS_ERR(newchrled.class)) {
  215. 		return PTR_ERR(newchrled.class);
  216. 	}
  217.  
  218. 	/* 5、创建设备 */
  219. 	newchrled.device = device_create(newchrled.class, NULL, newchrled.devid, NULL, NEWCHRLED_NAME);
  220. 	if (IS_ERR(newchrled.device)) {
  221. 		return PTR_ERR(newchrled.device);
  222. 	}
  223. 	
  224. 	return 0;
  225. }
  226.  
  227. /*
  228.  * @description	: 驱动出口函数
  229.  * @param 		: 无
  230.  * @return 		: 无
  231.  */
  232. static void __exit led_exit(void)
  233. {
  234. 	/* 取消映射 */
  235. 	iounmap(IMX6U_CCM_CCGR1);
  236. 	iounmap(SW_MUX_GPIO1_IO03);
  237. 	iounmap(SW_PAD_GPIO1_IO03);
  238. 	iounmap(GPIO1_DR);
  239. 	iounmap(GPIO1_GDIR);
  240.  
  241. 	/* 注销字符设备驱动 */
  242. 	cdev_del(&newchrled.cdev);/*  删除cdev */
  243. 	unregister_chrdev_region(newchrled.devid, NEWCHRLED_CNT); /* 注销设备号 */
  244.  
  245. 	device_destroy(newchrled.class, newchrled.devid);
  246. 	class_destroy(newchrled.class);
  247. }
  248.  
  249. module_init(led_init);
  250. module_exit(led_exit);
  251. MODULE_LICENSE("GPL");

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/180463?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号