Linux driver programming step-by-step (2)

Simple character Device Driver

1. Primary and secondary device numbers
The main device ID identifies the driver connected to the device. This device ID is used by the kernel and identifies the device under the corresponding driver.
In Linux, the slave number is a 32-bit dev_t type.

Typedef _ u32 _ kernel_dev_t;
Typedef _ kernel_dev_t dev_t; CrW ------- 1 Root 10, 1 Apr 11
2011 psaux
CrW ------- 1 Root 4, 1 Oct 2803: 04
Tty1
CrW-RW-1 root tty 4, 64 Apr 11
2011 ttys0
CrW-RW ---- 1 root uucp4, 65 Apr 11 2011
TTYs

Yes. In the/dev directory, use the $ LS-l command to display some results. We can see that the master device number of the tty driver is 4 (different system versions), and the secondary device number is different.

The first 12 digits identify the master device number	Major (dev_t Dev)	Obtain the master device number
The last 20 digits identify the device number	Minor (dev_t Dev)	Get this device number

The device number is generated by the Primary and Secondary device numbers.
Macro mkdev can be used.
Dev_t dev_num = mkdev (dev_t major, dev_t minor );

2. Allocate and release device numbers

In the character device of linux2.6 (as well as kernel3.0), the first thing to do is to apply for one or more device numbers.

1. /* Statically allocate the device number
2. * Parameter:
3. * First: the first device number allocated.
4. * Count: Number of allocated Devices
5. * Name: Device Name
6. * Return value:
7. * 0: Success
8. * Negative value: error, error code
9. */
10. Int register_chrdev_region (dev_t first, unsigned int count, char * Name );
12. /* Dynamically allocate device numbers
13. * Parameter:
14. * Dev: used to store the assigned device number value.
15. * Firstminor: Device number (usually 0)
     
16. * Count: Number of allocated Devices
17. * Name: Device Name
18. * Return value:
19. * 0: Success
20. * Negative value: error, error code
21. */
22. Int alloc_chrdev_region (dev_t * Dev, unsigned int firstminor, unsigned int count, char * Name );
    
24. /* Release the device number
25. * Parameter:
26. * First: Device number
27. * Count: Number of allocated Devices
28. */
29. Void unregister_chrdev_region (dev_t first, unsigned int count );

Static allocation of device numbers is used when an available device number is known. Before programming, programmers mostly know whether the device number is available or not, it cannot be ensured that the device is still available during system upgrade.
Therefore, dynamic allocation is strongly recommended in the Linux community. It will find available device numbers without conflict. You must release the device number when detaching the device.

3. An ineffective character Device Driver

1. # Include <Linux/init. h>
2. # Include <Linux/module. h>
3. # Include <Linux/types. h>
   
4. # Include <Linux/fs. h>
6. # Define simple_debug 1
7. # Define dev_count 2
   
8. # Define simple_name "simple_char"
   
10. Static int simple_major= 108;
11. Static int simple_minor = 0;
13. Static _ init int simple_init (void)
14. {
15. Dev_t dev;
16. Int err;
17. # If simple_debug
18. Printk (kern_info "in % s \ n", _ FUNC __);
19. # Endif
20. Dev = mkdev (simple_major, simple_minor); // obtain the device ID.
21. If (Dev> 0) // The device number is valid.
22. {
23. # If simple_debug
24. Printk (kern_info "try to register static char Dev % d \ n", Dev );
25. # Endif
26. Err = register_chrdev_region (Dev, dev_count, simple_name); // statically allocate the device number
27. If (ERR <0) // static Allocation Error try to use Dynamic Allocation
28. {
29. Printk (kern_warning "register static char Dev error \ n ");
30. Err = alloc_chrdev_region (& Dev, 0, dev_count, simple_name); // dynamically allocate device numbers
31. If (ERR <0)
32. {
33. Printk (kern_err "register char Dev error in line % d \ n" ,__ line __);
34. Goto error;
35. }
36. Else
37. {
38. Simple_major = major (Dev); // recalculate the master device number
39. Simple_minor = minor (Dev); // recalculate the device number
40. }
42. }
43. Else {
45. }
46. }
47. Else // The device number cannot be dynamically allocated
48. {
49. # If simple_debug
50. Printk (kern_info "try to register alloc char Dev \ n ");
51. # Endif
52. Err = alloc_chrdev_region (& Dev, 0, dev_count, simple_name );
53. If (ERR <0)
54. {
55. Printk (kern_err "register char Dev error in line % d \ n" ,__ line __);
56. Goto error;
57. }
58. Else
59. {
60. Simple_major = major (Dev );
61. Simple_minor = minor (Dev );
62. }
64. }
66. # If simple_debug
67. Printk (kern_info "register char Dev success major = % d Minor = % d \ n", simple_major, simple_minor );
68. # Endif
70. Error:
71. Return err;
72. }
74. Static _ exit void simple_exit (void)
75. {
76. Dev_t dev;
77. # If simple_debug
78. Printk (kern_info "in % s \ n", _ FUNC __);
79. # Endif
80. Dev = mkdev (simple_major, simple_minor );
81. Unregister_chrdev_region (Dev, dev_count); // release the device number.
82. }
84. Module_init (simple_init );
85. Module_exit (simple_exit );
87. Module_license ("GPL ");
88. Module_author ("kai_zhang (jsha.zk@163.com )");
89. Module_description ("simple char driver! ");

In this example, only the device number is assigned during module initialization, and the device Number of the driver is released when the module is canceled.
In the function, we can see the notorious goto function in application programming. In Linux-driven programming, the Goto function makes our programming more organized, it can be processed more quickly when an error occurs.
If errors are handled by the caller of the Function check, the module functions are bloated and huge. Therefore, we recommend that you use the Goto function properly.
After the module is loaded
Run $ CAT/proc/devices to view the device and master device Number of simple_char.

Here we can see that the original primary device number is not available, so we use the Dynamic Allocation of the device number, so we apply to the primary device number 249, we can add our device above, the specific operation will be discussed in the next section. Leave some suspense first.