Notes for debugging the RC 522 module on the LINUX platform

Hardware Platform:

1 master: SMDK Exynos4412 POP S5M8767A

2 RFID module: RC522 module provided by jundun Group

3. Communication Interface: SPI

Software Platform: Android ICS & kernel version 3.0.15

1. enable the master SPI

1 hardware enabling:

From the SMDK schematic, we can see that SPI0 is shared with I2C. SPI1 has been connected to other devices, and SPI2 is not used. Therefore, SPI2 is used here.

2 software enabling:

The SPI interface has been configured on the SMDK Exynos4412 master. You only need to enable macro config_jx64xx_dev_spi for use.

Open Method: make menuconfig à Device Drivers à SPI support à Samsung s364xx series type SPI.

After compilation, zImage is generated and burned into the Development Board.

Ii. Test the SPI on the master side

The master SPI has been enabled. Next, you can use a general SPI driver to test whether the master SPI hardware works properly.

Compile the program as a module: drivers/spi/spidev. c to generate spidev. ko, which is a common device-side SPI driver.

Compile the test program: Documentation/spi/spidev_test.c. First, modify the device "/dev/spidev2.0" for line 1: static const char * device = "/dev/spidev1.1 ", then compile the program as an application to generate the spidev_test, which is the test program corresponding to the SPI.

Grant root and system read/write permissions through the serial port:

Shell @ android:/$ su root

Shell @ android: // # mount-o remount-rw/system

[391.423930] EXT4-fs (mmcblk0p2): re-mounted. Opts: (null)

Shell @ android :/#

Push spidev. ko and spidev_test to the Development Board through adb:

Load DRIVER:

Shell @ android:/system # insmod spidev. ko

Short-circuited MISO and MOSI, that is, self-collect, and then run the test program:

As shown in, it indicates that data can be sent and received through SPI. If all data is displayed as 0, it means that SPI is not working properly. Next we can debug our RC522 module with confidence.

3. RC522 Device Driver debugging

The above experiment has proved that the SPI of the master can work normally, and then you can debug RC522. -Assume that your rfid_rc522 driver has been written, and now you only need to debug it-if the driver is not written, read another Blog.

1 open the Development Board related files: arch/arm/mach-exynos/mach-smdk4x12.c

Because spi2 is used, modify modalias = "rfid_rc522" in board_info to match spi_drviver.name in the driver. Otherwise, the probe function fails.

1. 988 static struct spi_board_info spi2_board_info [] _ initdata = {
   
2. 
   
3. 989 {
   
4. 
   
5. 990. modalias = "rfid_rc522 ",
   
6. 
   
7. 991. platform_data = NULL,
   
8. 
   
9. 992. max_speed_hz = 10*1000*1000,
   
10. 
    
11. 993. bus_num = 2,
    
12. 
    
13. 994. chip_select = 0,
    
14. 
    
15. 995. mode = SPI_MODE_0,
    
16. 
    
17. 996. controller_data = & spi2_csi [0],
    
18. 
    
19. 997}
    
20. 
    
21. 998 };

2. recompile the kernel and install it on the Development Board.

3. Compile the rc522 driver and copy the generated rfid_rc522.ko to the/system directory of the Development Board system through adb usb. Then, insmod rfid_rc522.ko, in this way, the driver is loaded into the kernel system in the form of modules. After the file is loaded successfully, the directory rfid_rc522_dev is displayed in the/dev directory.

4. Applications

The write function in the driver is:

Rc522_write (struct file * filp, const char * buf, size_t count, loff_t * f_pos );

The user space application write function is:

Write (rc522_fd, bufpw1, sizeof (bufpw1 ));

How do they connect?

In fact, the write function in the application is implemented by calling the core function sys_write (unsigned int fd, const char * buf, size_t count) in the operating system, while sys_write () the function encapsulates rc522_write () in the driver.

// Start from Forum

The driver of the character device is described as follows:

1. insmod driver. The device name and master device number applied by the driver can be obtained in/proc/devieces.

2. Obtain the master device number from/proc/devices and run the mknod command to create a device node file. This is to associate the device node file with the device driver by the master device number. The file attribute in the device node file specifies the function pointer implemented by the fops method in the driver.

3. the user program uses open to open the device node file. When the operating system kernel knows that the driver is working, it calls the open function in the fops Method for relevant work. The open method generally returns a File Identifier. In fact, it does not directly operate on it, but the system calls of the operating system work behind the scenes.

4. When you use the write function to operate the device file, the operating system calls the sys_write function. This function first obtains the inode pointer and flip pointer corresponding to the device node file through the file identifier. The inode pointer contains the device number, which tells the operating system which device driver should be used, the flip pointer contains the fops information, and the corresponding fops method function of the operating system can be found there.

5. Then, sys_write will call the write method in the driver to write the device.

Among them, 1-3 is performed in the user space, and 4-5 is performed in the kernel space. The user's write function is associated with the OS's write function by calling sys_write.

Note:

For Block devices, the writing mode still exists. This should be solved by the gnu c library. I will not discuss it here because I have not read the source code of the GNU C library.

// End of the Forum

The application source code is as follows:

1. # Include <stdio. h>
   
2. 
   
3. # Include <string. h>
   
4. 
   
5. # Include <stdlib. h>
   
6. 
   
7. # Include <sys/types. h>
   
8. 
   
9. # Include <unistd. h>
   
10. 
    
11. # Include <errno. h>
    
12. 
    
13. # Include <arpa/inet. h>
    
14. 
    
15. # Include <sys/time. h>
    
16. 
    
17. # Include <sys/types. h>
    
18. 
    
19. # Include <sys/stat. h>
    
20. 
    
21. # Include <fcntl. h>
    
22. 
    
23. # Include <sys/ioctl. h>
    
24. 
    
25. # Include <math. h>
    
26. 
    
27. 
    
28. Static enum IO_CMD {
    
29. 
    
30. READ_CARD = 0,
    
31. 
    
32. CHANGE_PASSWD = 1,
    
33. 
    
34. CHANGE_BLOCK = 3,
    
35. 
    
36. SET_RW_TIME = 4,
    
37. 
    
38. WRITE_CARD = 5,
    
39. 
    
40. };
    
41. 
    
42. 
    
43. Int main (int argc, char ** argv)
    
44. 
    
45. {
    
46. 
    
47. Int rc522_fd;
    
48. 
    
49. Int I, read_num;
    
50. 
    
51. Char r [256];
    
52. 
    
53. 
    
54. Printf ("test: rc522 % s \ n", _ DATE __, _ TIME __);
    
55. 
    
56. 
    
57. 
    
58. Printf ("test: before open rc522_fd \ n ");
    
59. 
    
60. Rc522_fd = open ("/dev/rfid_rc522_dev", O_RDWR );
    
61. 
    
62. 
    
63. 
    
64. Printf ("test: rc522_fd = % d \ n", rc522_fd );
    
65. 
    
66. If (rc522_fd =-1)
    
67. 
    
68. {
    
69. 
    
70. Printf ("test: Error Opening rc522 \ n ");
    
71. 
    
72. Return (-1 );
    
73. 
    
74. }
    
75. 
    
76. Printf ("test: wait 01 \ n ");
    
77. 
    
78. Sleep (1); // wait
    
79. 
    
80. Printf ("test: wait 02 \ n ");
    
81. 
    
82. 
    
83. /******* Never to open ********/
    
84. 
    
85. # If 0
    
86. 
    
87. // Change password as: 020202020202
    
88. 
    
89. Ioctl (rc522_fd, CHANGE_BLOCK, 0); // parameter 3: Select 0th
    
90. 
    
91. Ioctl (rc522_fd, CHANGE_PASSWD, 0 );
    
92. 
    
93. Char bufpw1 [6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
    
94. 
    
95. 
    
96. 
    
97. Write (rc522_fd, bufpw1, sizeof (bufpw1 ));
    
98. 
    
99. # Endif
    
100. 
     
101. 
     
102. Ioctl (rc522_fd, CHANGE_BLOCK, 0); // parameter 3: Select 0th
     
103. 
     
104. Ioctl (rc522_fd, READ_CARD, 0); // parameter 3 is useless
     
105. 
     
106. For (I = 0; I <3; I ++) // read the Three Card Numbers
     
107. 
     
108. {
     
109. 
     
110. Read_num = read (rc522_fd, r, 0 );
     
111. 
     
112. Printf ("test: I = % d read_num = % d", I, read_num );
     
113. 
     
114. If (read_num> 0 ){
     
115. 
     
116. Printf ("r = [0x %. 2X]", r [0]);
     
117. 
     
118. }
     
119. 
     
120. 
     
121. 
     
122. Printf ("\ n ");
     
123. 
     
124. Sleep (1 );
     
125. 
     
126. }
     
127. 
     
128. 
     
129. 
     
130. // Write something to the card
     
131. 
     
132. Ioctl (rc522_fd, CHANGE_BLOCK, 1); // parameter 3: select 2nd
     
133. 
     
134. Ioctl (rc522_fd, WRITE_CARD, 1 );
     
135. 
     
136. Printf ("before write card! \ N ");
     
137. 
     
138. 
     
139. 
     
140. Char buf [11] = "186652133xx ";
     
141. 
     
142. If (write (rc522_fd, buf, sizeof (buf )))
     
143. 
     
144. {
     
145. 
     
146. Printf ("write error \ n ");
     
147. 
     
148. }
     
149. 
     
150. // Read block [1], just writed
     
151. 
     
152. Ioctl (rc522_fd, CHANGE_BLOCK, 1); // parameter 3: Select 1st
     
153. 
     
154. Ioctl (rc522_fd, READ_CARD, 0); // parameter 3 is useless
     
155. 
     
156. Read_num = read (rc522_fd, r, 0 );
     
157. 
     
158. Printf ("read block [1] \ n The number you just writed is: % s \ n", r );
     
159. 
     
160. 
     
161. Printf ("test: close rc522_fd \ n ");
     
162. 
     
163. Close (rc522_fd );
     
164. 
     
165. Printf ("test: exit rc522_fd \ n ");
     
166. 
     
167. Return 0;
     
168. 
     
169. }

The Makefile compiled by the application is as follows:

1. # Comment/uncomment the following line to disable/enable debugging
   
2. 
   
3. # DEBUG = y
   
4. 
   
5. DEST_BIN_DIR = drivers/
   
6. 
   
7. EXTRA_CFLAGS + =-D_V3
   
8. 
   
9. # TESTFLAGS =-D_V3
   
10. 
    
11. 
    
12. # Add your debugging flag (or not) to CFLAGS
    
13. 
    
14. Ifeq ($ (DEBUG), y)
    
15. 
    
16. DEBFLAGS =-O-g-DSCULL_DEBUG # "-O" is needed to expand inlines
    
17. 
    
18. Else
    
19. 
    
20. DEBFLAGS =-O2
    
21. 
    
22. Endif
    
23. 
    
24. 
    
25. EXTRA_CFLAGS + = $ (DEBFLAGS)
    
26. 
    
27. EXTRA_CFLAGS + =-I $ (LDDINC)
    
28. 
    
29. EXTRA_CFLAGS + =-DREV_VERSION = $ (REV_VERSION)
    
30. 
    
31. LDFLAGS + = -- static
    
32. 
    
33. 
    
34. All: test
    
35. 
    
36. Clean:
    
37. 
    
38. Rm-rf test_rc522
    
39. 
    
40. 
    
41. 
    
42. Cp:
    
43. 
    
44. Cp-f test_rc522 $ (DEST_BIN_DIR)
    
45. 
    
46. Mv:
    
47. 
    
48. Mv-f test_rc522 $ (DEST_BIN_DIR)
    
49. 
    
50. Test:
    
51. 
    
52. Arm-linux-gcc $ (CFLAGS) $(LDFLAGS)-O2 test_rc522.c-o test_rc522
    
53. 
    
54. Depend. depend dep:
    
55. 
    
56. $ (CC) $ (CFLAGS)-M *. c>. depend
    
57. 
    
58. Ifeq (. depend, $ (wildcard. depend ))
    
59. 
    
60. Include. depend
    
61. 
    
62. Endif

During the test, close the card to the antenna area of RC522 to read the card ID normally.

V. Summary

This debugging was successful and encountered several major problems as follows:

1 SMDK Development Board SPI0 communication problems, started to think that driver problems, do not know how to test the Development Board SPI interface OK, after finding some information on the Internet, I found that the SPI driver can be tested by the driver modules and applications that come with the kernel.

2. Applications (test programs) cannot run on the development board system because the Linked Library is not set to static.

3 The VCC in RC522 needs 3.3 V, MOSI, CLK, and other TTL high levels, which are also 3.3 V. However, the high levels of GPIO output by the 4412 controller are all 1.8 V, so the module cannot work normally. Due to debugging, it is impossible to add an IC for TTL level conversion. Later, I tried to lower the VCC to 2.6 V, and the result module was working properly.