Micro2440 uses LEDS and BUTTONS drivers to realize button control of LED lights [Development Summary]

I recently played with the micro2440 of Friendly Arm and realized the function of controlling the LED light on and off with a button. I would like to summarize it here. If there are any errors, I hope experts can point them out. I also hope to help novices who have just learned to drive.

First post the LEDs driver:

1. #include 

2. #include 

3. #include 

4. #include 

5. #include 

6. #include 

7. #include 

8. #include 

9. #include 

10. #include 

11. #include 

12. #include 

13. #include 

14. #include 

15. #include 

16. #include 

17. #include 

18. #include 

19. #include 

20. #include 

21. #include 

22. #include 

23. #include 

26. #define DEVICE_NAME "leds"

28. static unsigned long led_table [] = {

29. S3C2410_GPB5,

30. S3C2410_GPB6,

31. S3C2410_GPB7,

32. S3C2410_GPB8,

33. };

35. static unsigned int led_cfg_table [] = {

36. S3C2410_GPB5_OUTP,

37. S3C2410_GPB6_OUTP,

38. S3C2410_GPB7_OUTP,

39. S3C2410_GPB8_OUTP,

40. };

42. static int sbc2440_leds_ioctl(

43. struct inode *inode,

44. struct file *file,

45. unsigned int cmd,

46. unsigned long arg)

47. {

48. switch(cmd) {

49. case 0:

50. case 1:

51. if (arg > 4) {

52. return -SINGLE SELECT;

53. }

54. s3c2410_gpio_setpin(led_table[arg], !cmd);

55. return 0;

56. default:

57. return -SINGLE SELECT;

58. }

59. }

61. static struct file_operations dev_fops = {

62. .owner  =   THIS_MODULE,

63. .ioctl  =   sbc2440_leds_ioctl,

64. };

66. static struct miscdevice misc = {

67. .minor = MISC_DYNAMIC_MINOR,

68. .name = DEVICE_NAME,

69. .fops = &dev_fops,

70. };

72. static int __init dev_init(void)

73. {

74. int ret;

76. int i;

78. for (i = 0; i < 4; i++) {

79. s3c2410_gpio_cfgpin(led_table[i], led_cfg_table[i]);

80. s3c2410_gpio_setpin(led_table[i], 0);

81. }

83. ret = misc_register(&misc);

85. printk (DEVICE_NAME"tinitializedn");

87. return ret;

88. }

90. static void __exit dev_exit(void)

91. {

92. misc_deregister(&misc);

93. }

95. module_init(dev_init);

96. module_exit(dev_exit);

97. MODULE_LICENSE("GPL");

98. MODULE_AUTHOR("FriendlyARM Inc.");

The key point of this driver is to provide an ioctl device method. When the ioctl (leds' fd, cmd, arg) system call is used in the application, the system will enter the kernel state and call sbc2440_leds_ioctl() to control the on and off of the light.

The buttons driver is posted below:

1. #include 

2. #include 

3. #include 

4. #include 

5. #include 

6. #include 

7. #include 

8. #include 

9. #include 

10. #include 

11. #include 

12. #include 

13. #include 

14. #include 

15. #include 

17. #define DEVICE_NAME     "buttons"

19. struct button_irq_desc {

20. int irq;

21. int pin;

22. int pin_setting;

23. int number;

24. char *name;

25. };

27. #if !defined (CONFIG_QQ2440_BUTTONS)

28. static struct button_irq_desc button_irqs [] = {

29. {IRQ_EINT8 , S3C2410_GPG0 ,  S3C2410_GPG0_EINT8  , 0, "KEY0"},

30. {IRQ_EINT11, S3C2410_GPG3 ,  S3C2410_GPG3_EINT11 , 1, "KEY1"},

31. {IRQ_EINT13, S3C2410_GPG5 ,  S3C2410_GPG5_EINT13 , 2, "KEY2"},

32. {IRQ_EINT14, S3C2410_GPG6 ,  S3C2410_GPG6_EINT14 , 3, "KEY3"},

33. {IRQ_EINT15, S3C2410_GPG7 ,  S3C2410_GPG7_EINT15 , 4, "KEY4"},

34. {IRQ_EINT19, S3C2410_GPG11,  S3C2410_GPG11_EINT19, 5, "KEY5"},

35. };

36. #else /* means QQ */

37. static struct button_irq_desc button_irqs [] = {

38. {IRQ_EINT19, S3C2410_GPG11, S3C2410_GPG11_EINT19, 0, "KEY0"},

39. {IRQ_EINT11, S3C2410_GPG3,  S3C2410_GPG3_EINT11,  1, "KEY1"},

40. {IRQ_EINT2,  S3C2410_GPF2,  S3C2410_GPF2_EINT2,   2, "KEY2"},

41. {IRQ_EINT0,  S3C2410_GPF0,  S3C2410_GPF0_EINT0,   3, "KEY3"},

42. {       -1,            -1,                 -1,    4, "KEY4"},

43. {       -1,            -1,                 -1,    5, "KEY5"},

44. };

45. #endif

46. static volatile char key_values [] = {'0', '0', '0', '0', '0', '0'};

48. static DECLARE_WAIT_QUEUE_HEAD(button_waitq);

50. static volatile int ev_press = 0;

53. static irqreturn_t buttons_interrupt(int irq, void *dev_id)

54. {

55. struct button_irq_desc *button_irqs = (struct button_irq_desc *)dev_id;

56. int down;

58. // delay(0);

59. down = !s3c2410_gpio_getpin(button_irqs->pin);

61. if (down != (key_values[button_irqs->number] & 1)) { // Changed

63. key_values[button_irqs->number] = '0' + down;

65. ev_press = 1;

66. wake_up_interruptible(&button_waitq);

67. }

69. return IRQ_RETVAL(IRQ_HANDLED);

70. }

73. static int s3c24xx_buttons_open(struct inode *inode, struct file *file)

74. {

75. int i;

76. int err = 0;

78. for (i = 0; i < sizeof(button_irqs)/sizeof(button_irqs[0]); i++) {

79. if (button_irqs[i].irq < 0) {

80. continue;

81. }

82. err = request_irq(button_irqs[i].irq, buttons_interrupt, IRQ_TYPE_EDGE_BOTH,

83. button_irqs[i].name, (void *)&button_irqs[i]);

84. if (err)

85. break;

86. }

88. if (err) {

89. i--;

90. for (; i >= 0; i--) {

91. if (button_irqs[i].irq < 0) {

92. continue;

93. }

94. disable_irq(button_irqs[i].irq);

95. free_irq(button_irqs[i].irq, (void *)&button_irqs[i]);

96. }

97. return -EBUSY;

98. }

100. ev_press = 1;

102. return 0;

103. }

106. static int s3c24xx_buttons_close(struct inode *inode, struct file *file)

107. {

108. int i;

110. for (i = 0; i < sizeof(button_irqs)/sizeof(button_irqs[0]); i++) {

111. if (button_irqs[i].irq < 0) {

112. continue;

113. }

114. free_irq(button_irqs[i].irq, (void *)&button_irqs[i]);

115. }

117. return 0;

118. }

121. static int s3c24xx_buttons_read(struct file *filp, char __user *buff, size_t count, loff_t *offp)

122. {

123. unsigned long err;

125. if (!ev_press) {

126. if (filp->f_flags & O_NONBLOCK)

127. return -EAGAIN;

128. else

129. wait_event_interruptible(button_waitq, ev_press);

130. }

132. ev_press = 0;

134. err = copy_to_user(buff, (const void *)key_values, min(sizeof(key_values), count));

136. return err ? -EFAULT : min(sizeof(key_values), count);

137. }

139. static unsigned int s3c24xx_buttons_poll( struct file *file, struct poll_table_struct *wait)

140. {

141. unsigned int mask = 0;

142. poll_wait(file, &button_waitq, wait);

143. if (ev_press)

144. mask |= POLLIN | POLLRDNORM;

145. return mask;

146. }

149. static struct file_operations dev_fops = {

150. .owner   =   THIS_MODULE,

151. .open    =   s3c24xx_buttons_open,

152. .release =   s3c24xx_buttons_close,

153. .read    =   s3c24xx_buttons_read,

154. .poll    =   s3c24xx_buttons_poll,

155. };

157. static struct miscdevice misc = {

158. .minor = MISC_DYNAMIC_MINOR,

159. .name = DEVICE_NAME,

160. .fops = &dev_fops,

161. };

163. static int __init dev_init(void)

164. {

165. int ret;

167. ret = misc_register(&misc);

169. printk (DEVICE_NAME"tinitializedn");

171. return ret;

172. }

174. static void __exit dev_exit(void)

175. {

176. misc_deregister(&misc);

177. }

179. module_init(dev_init);

180. module_exit(dev_exit);

181. MODULE_LICENSE("GPL");

182. MODULE_AUTHOR("FriendlyARM Inc.");

The key to this driver (For a detailed analysis of the button driver, please see my other article mini2440_buttons.c driver interpretation http://www.linuxidc.com/Linux/2011-07/38768.htm )

1. It is the device method of s3c24xx_buttons_read. When the read (buttons fs, key status array, how many bits to read) system call is used in the application, the kernel state will be entered to call the s3c24xx_buttons_read function. This function will enter the interruptible sleep state through wait _event_interruptible() and wait for the arrival of the interrupt.

2. The buttons_interrupt interrupt service function is defined, which processes the corresponding key value and wakes up the sleep state.

The application is as follows:

1. #include 

2. #include 

3. #include 

4. #include 

5. #include 

6. #include 

7. #include 

8. #include 

9. #include