[Linux Driver] character device driver learning Note (i)

One, what does the main device number and the secondary device number mean? Linu kernel is if the main device number to find the driver, the secondary device number to find the device.

A: Usually a main device number represents a driver, for example, in a block device, a master device number represents a EMMC device, the different secondary device number represents a different partition

The Linux kernel allows multiple drives to share a master device number, but more devices follow a principle that drives a master device number. Kernel maintainer a global hash table with the main device number key, while the data portion of the hash table is a pointer to the driver (only one secondary device) corresponding to the master device number device, or a pointer to an array of multiple secondary device drivers (secondary device shared master number)

Second, write the general order of the character devices

First, call the Kmalloc memset function to initialize the related struct (such as the device structure)
Second, register the corresponding driver, such as platform driver call Platform_driver_register (&driver) to register, driver is a full static variable.

[CPP]View Plaincopy

2. struct test_dev{
4. struct Cdev cdev;
6. Char *test_devname;
8. Char actname[32];
10. unsigned int index;
12. struct Semphare sem;
14. }
16. Static struct Platform_driver test_driver = {
18. . Probe = Test_probe,
20. . remove = Test_remove,
22. . Driver = {
24. . Name = "Test_char",
26. . Owner = This_module,
28. },
30. };
36. #define TEST_NUM 10
38. Static struct Test_dev *test_devices;
40. static int __init test_init (void)
42. {
44. int result;
46. Test_devices=kmalloc (test_num*sizeof (struct test_dev), gfp_kernel);
48. if (!test_devices)
50. {
52. result =-enomem
54. PRINTK ("Alloc test_devices fail\n");
56. Goto Fail_malloc;
58. }
60. memset (test_devices,0,test_num*sizeof (struct test_dev));
62. result = Platform_driver_register (&test_driver);
64. if (result)
66. {
68. PRINTK ("fail to register Test_driver");
70. Goto Fail_driver_register;
72. }
74. return 0
76. Fail_driver_register:
78. return result;
80. Fail_malloc:
82. return result;
84. }
86. Module_init (Test_init);

Third, the next call to the Test_probe () function, which first assigns the main device number and the secondary device number to the Alloc_chrdev_region () function, and then calls the Cdev_init () function to register the true character device, void Cdev_init ( struct cdev*cdev,struct file_operations *fops) finally calls the Cdev_add () function to tell the kernel the structure of the information for the Init cdev_add (struct cdev*cdev,dev_t num, unsigned int count)

[CPP]View Plaincopy

2. int Test_probe (struct platform_device *dev)
4. {
6. int result;
8. dev_t Devno;
10. result = Alloc_chrdev_region (&devno,0,test_num,"Testchar");
12. if (result<0)
14. {
16. PRINTK ();
18. Goto Fail_alloc_chrdev;
20. }
22. Major = Major (DEVNO);
24. For (int i=0;i<test_num;i++)
26. {
28. Devno=mkdev (Major,i);
30. Cdev_init (&test_devices[i].cdev,&test_fops);
32. Test_devices[i].cdev.owner = This_module;
34. Test_devices[i].cdev.ops = &test_fops;
36. result = Cdev_add (&test_devices[i].cedv,devno,1);
38. if (result)
40. {
42. PRINTK ("Cdev add fail\n");
44. Goto Fail_register_chrdev;
46. }
50. }
52. return 0;
54. Fail_register_chrdev:
56. Cdev_del (&test_devices[i].cdev);
58. Unregister_chrdev_region (MKDEV (major,0), test_num);
62. }

Three, blocking I/O

If, in the read write method of the calling character device, the device is not ready to cause the process to be read by the user layer to block (the default), place it in hibernation until the request can continue. Place the process into hibernation two points to note
(1) Do not sleep in the atomic context, the driver can no longer have a spin lock, RCU lock time Sleep, the process of having a semaphore sleep is legal, but waiting for this semaphore of other processes must also sleep, so the process has a semaphore time to sleep short enough
(2) When the process wakes up without knowing what has happened, check to make sure that the conditions we wait for are really true.
Ways to let the process hibernate:
Wait_event () Related functions
Wake-up Process method
WAKE_UP () Related functions

How to implement non-blocking I/O operations
A: Fill the O_nonblock flag in the Filp->f_flags, if open in a non-blocking way, if the device does not have ready data at this time, then the-eagain error will be returned.

Four, the device file access control

1, let a process exclusive device, by maintaining an atomic variable

Use instance: the ADB driver, which only lets ADBD one process use the device at a time.

[CPP]View Plaincopy

2. static int Scull_s_poen (struct inode*inode,struct FILE*FILP)
4. {
6. struct Scull_dev *dev = &scull_s_device;
8. if (!atomic_dec_and_test (&scull_s_available)) {
10. Atomic_inc (&scull_s_available);
12. Return-ebusy;
14. }
16. if ((Filp->flags & O_accmode) ==o_wronly)
18. Scull_trim (Dev);
20. filp->priate_data=dev;
22. return 0;
24. }

2, limit access by only one user at a time

[CPP]View Plaincopy

2. Spin_lock (&scull_u_lock); //scull_u_lock is a global variable, so with spin lock, the use of optional lock can not sleep
4. if (Scull_u_count && (scull_u_owner! = current->uid) && (scull_u_owner! = current->euid) & &!capable (Cap_dac_override))
6. {
8. Spin_unlock (&scull_u_lock);
10. Return-ebusy;
12. }
14. if (Scull_u_count = = 0)
16. {
18. scull_u_owner=current->uid; //The first user to access the device belongs to the primary user
20. }
22. scull_u_count++;
24. Spin_unlock (&scull_u_lock);

[Linux Driver] character device driver learning Note (i)