【100ask】IMX6ULL开发板用SPI驱动RC522模块
目录
一、问题汇总：
1.无法寻卡
2.寻卡不稳定
二、修改设备树
三、驱动程序
四、测试程序
1.rc522_ap.c
2.rc522_app.h
3.rc522_test.c
4.Makefile
前言：
CSDN上大部分对于RC522的文章都是正点的，虽然文章写的挺详细，两块板子也挺相近的，但是对于我们使用100ask_imx6ull pro的用户来说还是有很多地方不适配的，小问题特别多。
翻烂了整个CSDN和百问网的论坛，终于成功使用100ask_imx6ull pro开发板成功使用RC522模块读取到了卡号。这是参考的文章（有代码）：imx6ull_pro和rc522使用spi通讯一直找不到卡，发送MI_ERR消息 - 嵌入式Linux开发 - 嵌入式开发问答社区
一、问题汇总：
1.无法寻卡
由于spi-controller会自动对ecspi1下的cs_gpio拉高或者拉低，可能在spi_sync的数据发送过程中有bug， 所以不能使用spi_controller提供的片选引脚，不然的话，spi_sync会操控这个引脚但是用户却不知道是拉高还是拉低。
所以应该找一个可以使用的gpio当作片选引脚，然后再在读写函数中控制它，需要将片选引脚改为了普通gpio让用户控制cs_gpio，在spi_sync前拉低电平，之后拉高电平。
2.寻卡不稳定
SPI时钟频率过快，会导致寻卡很不稳定，大部分时间寻不到卡，偶尔才能寻到卡。
解决办法就是降低SPI的时钟频率，这样就不会寻不到卡了。
二、修改设备树
修改设备树，主要针对上面两个问题：
1.使用别的gpio当作片选引脚
2.修改SPI的时钟频率
三、驱动程序
/*
* Simple synchronous userspace interface to SPI devices
*
* Copyright (C) 2006 SWAPP
* Andrea Paterniani <a.paterniani@swapp-eng.it>
* Copyright (C) 2007 David Brownell (simplification, cleanup)
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <linux/init.h>
#include <linux/module.h>
#include <linux/ioctl.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/list.h>
#include <linux/errno.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/compat.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/acpi.h>
#include <linux/spi/spi.h>
#include <linux/spi/spidev.h>
#include <linux/uaccess.h>
#include <linux/gpio/consumer.h>
#include <linux/delay.h>
#include <linux/of_gpio.h>
/*-------------------------------------------------------------------------*/
static struct spi_device *rc522_spi_device;
static struct device *rc522_device;
static int major;
static struct gpio_desc *rst_gpio;
static struct gpio_desc *cs_gpio;
//static struct device_node *rc522_node;
static unsigned char read_one_reg(unsigned char reg);
static void write_one_reg(unsigned char reg, unsigned char value);
static void rc522_reset_disable(void)
{
gpiod_set_value(rst_gpio, 1);
}
static void rc522_reset_enable(void)
{
gpiod_set_value(rst_gpio, 0);
}
static int rc522_drv_open(struct inode *inode, struct file *file)
{
printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
rc522_reset_disable();
udelay(1);
rc522_reset_enable();
udelay(1);
rc522_reset_disable();
udelay(1);
return 0;
}
static ssize_t rc522_drv_read(struct file *file, char __user *buf, size_t size, loff_t *offset)
{
int ret = 0;
unsigned char ker_buf[2];
memset(ker_buf, 0, sizeof(ker_buf) / sizeof(ker_buf[0]));
ret = copy_from_user(&ker_buf[0], buf, 1);
if(ret < 0)
{
printk("copy_from_user err!\n");
return -1;
}
ker_buf[1] = read_one_reg(ker_buf[0]);
ret = copy_to_user((void *)buf, &ker_buf[1], 1);
if(ret < 0)
{
printk("copy_to_user err!\n");
return -1;
}
return 0;
}
static ssize_t rc522_drv_write(struct file *file, const char __user *buf, size_t size, loff_t *offset)
{
int ret = 0;
unsigned char ker_buf[2];
memset(ker_buf, 0, sizeof(ker_buf) / sizeof(ker_buf[0]));
ret = copy_from_user(ker_buf, buf, 2);
if(ret < 0)
{
printk("copy_from_user err!\n");
return -1;
}
write_one_reg(ker_buf[0], ker_buf[1]);
return 0;
}
static int rc522_drv_close(struct inode *inode, struct file *file)
{
printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
rc522_reset_enable();
gpiod_put(rst_gpio);
gpiod_put(cs_gpio);
return 0;
}
static const struct file_operations spidev_fops = {
.owner = THIS_MODULE,
/* REVISIT switch to aio primitives, so that userspace
* gets more complete API coverage. It'll simplify things
* too, except for the locking.
*/
.open = rc522_drv_open,
.read = rc522_drv_read,
.write = rc522_drv_write,
.release = rc522_drv_close,
};
int value;
static int spi_read_regs(unsigned char reg, unsigned char *buf, int len)
{
int ret = 0;
unsigned char txdata[len];
struct spi_message message;
struct spi_transfer *transfer;
/* 片选使能 */
gpiod_set_value(cs_gpio, 0);
/* 申请并初始化 spi_transfer */
transfer = kzalloc(sizeof(struct spi_transfer), GFP_KERNEL);
/* 将读寄存器地址修改为正确的格式 addr = ((reg << 1) & 0x7E) | 0x80 */
txdata[0] = ((reg << 1) & 0x7E) | 0x80;
transfer->tx_buf = txdata;
transfer->len = 1;
/* 初始化 spi_message */
spi_message_init(&message);
/* 将 spi_transger 加入 spi_message 的尾部 */
spi_message_add_tail(transfer, &message);
/* 开启 spi_sync 传输地址 */
ret = spi_sync(rc522_spi_device, &message);
if(ret < 0)
{
printk("spi_sync err!\n");
return -1;
}
/* 读该寄存器的数据 */
txdata[0] = 0xff;
transfer->rx_buf = buf;
transfer->len = len;
/* 初始化 spi_message */
spi_message_init(&message);
/* 将 spi_transger 加入 spi_message 的尾部 */
spi_message_add_tail(transfer, &message);
/* 开启 spi_sync 接收数据 */
ret = spi_sync(rc522_spi_device, &message);
if(ret < 0)
{
printk("spi_sync err!\n");
return -1;
}
/*释放 spi_transfer */
kfree(transfer);
/* 片选失能 */
gpiod_set_value(cs_gpio, 1);
return ret;
}
static int spi_write_regs(unsigned char reg, unsigned char *buf, int len)
{
int ret = 0;
unsigned char txdata[len];
struct spi_message message;
struct spi_transfer *transfer;
/* 片选使能 */
gpiod_set_value(cs_gpio, 0);
/* 申请并初始化 spi_transfer */
transfer = kzalloc(sizeof(struct spi_transfer), GFP_KERNEL);
/* 将写寄存器地址修改为正确的格式 addr = ((reg << 1) & 0x7E)*/
txdata[0] = (reg << 1) & 0x7E;
transfer->tx_buf = txdata;
transfer->len = 1;
/* 初始化 spi_message */
spi_message_init(&message);
/* 将 spi_transger 加入 spi_message 的尾部 */
spi_message_add_tail(transfer, &message);
/* 开启 spi_sync 传输地址 */
ret = spi_sync(rc522_spi_device, &message);
if(ret < 0)
{
printk("spi_sync err!\n");
return -1;
}
/* 写该寄存器的数据 */
transfer->tx_buf = buf;
transfer->len = len;
/* 初始化 spi_message */
spi_message_init(&message);
/* 将 spi_transger 加入 spi_message 的尾部 */
spi_message_add_tail(transfer, &message);
/* 开启 spi_sync 传输写该寄存器的数据 */
ret = spi_sync(rc522_spi_device, &message);
if(ret < 0)
{
printk("spi_sync err!\n");
return -1;
}
/*释放 spi_transfer */
kfree(transfer);
/* 片选失能 */
gpiod_set_value(cs_gpio, 1);
return ret;
}
/* 读一个地址的一个字节的数据*/
static unsigned char read_one_reg(unsigned char reg)
{
unsigned char buf = 0;
spi_read_regs(reg, &buf, 1);
return buf;
}
/* 写一个地址的一个字节的数据*/
static void write_one_reg(unsigned char reg, unsigned char value)
{
unsigned char buf = value;
spi_write_regs(reg, &buf, 1);
}
/* rc522 初始化 */
static void rc522_init(void)
{
int ret;
rc522_reset_disable();
udelay(10);
ret = gpiod_direction_output(cs_gpio, 1);
if(ret < 0)
{
printk("gpio_direction_output err!\n");
}
udelay(10);
}
/*-------------------------------------------------------------------------*/
/* The main reason to have this class is to make mdev/udev create the
* /dev/spidevB.C character device nodes exposing our userspace API.
* It also simplifies memory management.
*/
static struct class *rc522_class;
/*-------------------------------------------------------------------------*/
static int spidev_probe(struct spi_device *spi)
{
int ret = 0;
printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
/* 1. 记录spi设备 */
rc522_spi_device = spi;
/* 2. 注册spi字符设备 */
major = register_chrdev(0, "100ask_rc522", &spidev_fops);
if(major < 0)
{
printk("register_chrdev err!\n");
return -1;
}
rc522_class = class_create(THIS_MODULE, "100ask_rc522_class");
if(rc522_class == NULL)
{
printk("class_create err!\n");
return -1;
}
rc522_device = device_create(rc522_class, NULL, MKDEV(major, 0), NULL, "100ask_rc522");
if(rc522_device == NULL)
{
printk("device_create err!\n");
return -1;
}
/* 获取cs_gpio */
cs_gpio = gpiod_get(&spi->dev, "cs", 0);
if(cs_gpio == NULL)
{
printk("gpiod_get cs_gpio err!\n");
return -1;
}
/* 获取rst_gpio */
rst_gpio = gpiod_get(&spi->dev, "rst", 0);
if(rst_gpio == NULL)
{
printk("gpiod_get rst_gpio err!\n");
return -1;
}
/* spi 模式0 */
spi->mode = SPI_MODE_0;
/* 启动 spi */
spi_setup(spi);
/* 记录 spi device 返回给数据传输函数 */
rc522_spi_device = spi;
rc522_init();
return ret;
/*rst_node = of_find_node_by_path("/rc522_rst_gpio");
if(rst_node == NULL)
{
printk("of_find_node_by_path err!\n");
return -1;
}
rst_gpio = of_get_named_gpio(rst_node, "rst-gpio", 0);
if(rst_gpio < 0)
{
printk("of_get_named_gpio err!\n");
return -1;
}
ret = gpio_direction_output(rst_gpio, 1);
if(ret < 0)
{
printk("gpiod_direction_output err!\n");
return -1;
}
cs_node = of_find_node_by_path("/rc522_cs_gpio");
if(cs_node == NULL)
{
printk("of_find_node_by_path err!\n");
return -1;
}
cs_gpio = of_get_named_gpio(cs_node, "cs-gpio", 0);
if(cs_gpio < 0)
{
printk("of_get_named_gpio err!\n");
return -1;
}
ret = gpio_direction_output(cs_gpio, 1);
if(ret < 0)
{
printk("gpiod_direction_output err!\n");
return -1;
}
*/
/*rc522_node = of_find_node_by_path("/soc/aips-bus@02000000/spba-bus@02000000/ecspi@02008000");
if(rc522_node == NULL)
{
//printk("of_find_node_by_path err!\n");
//return -1;
}
cs_gpio = of_get_named_gpio(rc522_node, "cs-gpios", 0);
if(cs_gpio < 0)
{
//printk("of_get_named_gpio_flags err!\n");
//return -1;
}
gpio_direction_output(cs_gpio, 1);
*/
}
static int spidev_remove(struct spi_device *spi)
{
printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
/* 释放 rst_gpio, cs_gpio */
gpiod_put(rst_gpio);
gpiod_put(cs_gpio);
/* 卸载spi字符设备 */
device_destroy(rc522_class, MKDEV(major, 0));
class_destroy(rc522_class);
unregister_chrdev(major, "100ask_rc522");
return 0;
}
static const struct of_device_id rc522_of_match[] = {
{ .compatible = "100ask,rc522" },
{},
};
static const struct spi_device_id rc522_id[] = {
{"100ask,rc522", 0},
{}
};
static struct spi_driver rc522_spi_driver = {
.driver = {
.name = "100ask_spi_rc522_drv",
.of_match_table = of_match_ptr(rc522_of_match),
},
.probe = spidev_probe,
.remove = spidev_remove,
.id_table = rc522_id,
/* NOTE: suspend/resume methods are not necessary here.
* We don't do anything except pass the requests to/from
* the underlying controller. The refrigerator handles
* most issues; the controller driver handles the rest.
*/
};
/*-------------------------------------------------------------------------*/
static int __init rc522_spi_init(void)
{
int status;
printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
status = spi_register_driver(&rc522_spi_driver);
if (status < 0)
printk("spi_register_driver err!\n");
else
printk("spi_register_driver sucess!\n");
return status;
}
static void __exit rc522_spi_exit(void)
{
printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
spi_unregister_driver(&rc522_spi_driver);
}
module_init(rc522_spi_init);
module_exit(rc522_spi_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("JunCxue");
四、测试程序
1.rc522_ap.c
#include <stdlib.h> /* using sleep() */
#include <fcntl.h> /* using file operation */
#include <sys/ioctl.h> /* using ioctl() */
#include <asm/ioctls.h>
#include <unistd.h> //sleep write read close
// #include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "rc522_app.h"
#include <pthread.h>
#include <semaphore.h>
#define ReadFlag 1
#define WriteFlag 0
int fd = 0;//文件句柄
/**
* @brief 读RC522寄存器
* @param ucAddress，寄存器地址
* @retval 寄存器的当前值
*/
uint8_t ReadRawRC( uint8_t Address )
{
uint8_t buf[1];
buf[0] = Address;
read(fd,buf,1);
return buf[0];
}
/**
* @brief 写RC522寄存器
* @param ucAddress，寄存器地址
* @param ucValue，写入寄存器的值
* @retval 无
*/
void WriteRawRC( uint8_t Address, uint8_t Value )
{
uint8_t buf[2];
buf[0] = Address;
buf[1] = Value;
write(fd,buf,2);
}
/**
* @brief 对RC522寄存器置位
* @param ucReg，寄存器地址
* @param ucMask，置位值
* @retval 无
*/
void SetBitMask ( uint8_t ucReg, uint8_t ucMask )
{
uint8_t ucTemp;
ucTemp = ReadRawRC ( ucReg );
WriteRawRC ( ucReg, ucTemp | ucMask ); // set bit mask
}
/**
* @brief 对RC522寄存器清位
* @param ucReg，寄存器地址
* @param ucMask，清位值
* @retval 无
*/
void ClearBitMask ( uint8_t ucReg, uint8_t ucMask )
{
uint8_t ucTemp;
ucTemp = ReadRawRC ( ucReg );
WriteRawRC ( ucReg, ucTemp & ( ~ ucMask) ); // clear bit mask
}
/**
* @brief 开启天线
* @param 无
* @retval 无
*/
void PcdAntennaOn ( void )
{
uint8_t uc;
uc = ReadRawRC ( TxControlReg );
if ( ! ( uc & 0x03 ) )
SetBitMask(TxControlReg, 0x03);
}
/**
* @brief 关闭天线
* @param 无
* @retval 无
*/
void PcdAntennaOff ( void )
{
ClearBitMask ( TxControlReg, 0x03 );
}
/**
* @brief 复位RC522
* @param 无
* @retval 0:复位成功
*/
int PcdReset(void)
{
fd = open("/dev/100ask_rc522",O_RDWR);
if(fd < 0)
{
printf("open rc522_drv error %d\n",fd);
return fd;
}
WriteRawRC ( CommandReg, 0x0f );
while ( ReadRawRC ( CommandReg ) & 0x10 );
//定义发送和接收常用模式 和Mifare卡通讯，CRC初始值0x6363
WriteRawRC ( ModeReg, 0x3D );
WriteRawRC ( TReloadRegL, 30 ); //16位定时器低位
WriteRawRC ( TReloadRegH, 0 ); //16位定时器高位
WriteRawRC ( TModeReg, 0x8D ); //定义内部定时器的设置
WriteRawRC ( TPrescalerReg, 0x3E ); //设置定时器分频系数
WriteRawRC ( TxAutoReg, 0x40 ); //调制发送信号为100%ASK
return 0;
}
/**
* @brief 设置RC522的工作方式
* @param ucType，工作方式
* @retval 无
*/
void M500PcdConfigISOType ( uint8_t ucType )
{
if ( ucType == 'A') //ISO14443_A
{
ClearBitMask ( Status2Reg, 0x08 );
WriteRawRC ( ModeReg, 0x3D ); //3F
WriteRawRC ( RxSelReg, 0x86 ); //84
WriteRawRC( RFCfgReg, 0x7F ); //4F
WriteRawRC( TReloadRegL, 30 );
WriteRawRC ( TReloadRegH, 0 );
WriteRawRC ( TModeReg, 0x8D );
WriteRawRC ( TPrescalerReg, 0x3E );
usleep(10000);
PcdAntennaOn ();//开天线
}
}
/**
* @brief 通过RC522和ISO14443卡通讯
* @param ucCommand，RC522命令字
* @param pInData，通过RC522发送到卡片的数据
* @param ucInLenByte，发送数据的字节长度
* @param pOutData，接收到的卡片返回数据
* @param pOutLenBit，返回数据的位长度
* @retval 状态值= MI_OK，成功
*/
char PcdComMF522 ( uint8_t ucCommand,
uint8_t * pInData,
uint8_t ucInLenByte,
uint8_t * pOutData,
uint32_t * pOutLenBit )
{
char cStatus = MI_ERR;
uint8_t ucIrqEn = 0x00;
uint8_t ucWaitFor = 0x00;
uint8_t ucLastBits;
uint8_t ucN;
uint32_t ul;
switch ( ucCommand )
{
case PCD_AUTHENT: //Mifare认证
ucIrqEn = 0x12; //允许错误中断请求ErrIEn 允许空闲中断IdleIEn
ucWaitFor = 0x10; //认证寻卡等待时候 查询空闲中断标志位
break;
case PCD_TRANSCEIVE: //接收发送 发送接收
ucIrqEn = 0x77; //允许TxIEn RxIEn IdleIEn LoAlertIEn ErrIEn TimerIEn
ucWaitFor = 0x30; //寻卡等待时候 查询接收中断标志位与 空闲中断标志位
break;
default:
break;
}
//IRqInv置位管脚IRQ与Status1Reg的IRq位的值相反
WriteRawRC ( ComIEnReg, ucIrqEn | 0x80 );
//Set1该位清零时，CommIRqReg的屏蔽位清零
ClearBitMask ( ComIrqReg, 0x80 );
//写空闲命令
WriteRawRC ( CommandReg, PCD_IDLE );
//置位FlushBuffer清除内部FIFO的读和写指针以及ErrReg的BufferOvfl标志位被清除
SetBitMask ( FIFOLevelReg, 0x80 );
for ( ul = 0; ul < ucInLenByte; ul ++ )
WriteRawRC ( FIFODataReg, pInData [ ul ] ); //写数据进FIFOdata
WriteRawRC ( CommandReg, ucCommand ); //写命令
if ( ucCommand == PCD_TRANSCEIVE )
//StartSend置位启动数据发送 该位与收发命令使用时才有效
SetBitMask(BitFramingReg,0x80);
ul = 1000; //根据时钟频率调整，操作M1卡最大等待时间25ms
do //认证 与寻卡等待时间
{
ucN = ReadRawRC ( ComIrqReg ); //查询事件中断
ul --;
} while ( ( ul != 0 ) && ( ! ( ucN & 0x01 ) ) && ( ! ( ucN & ucWaitFor ) ) );
ClearBitMask ( BitFramingReg, 0x80 ); //清理允许StartSend位
if ( ul != 0 )
{
//读错误标志寄存器BufferOfI CollErr ParityErr ProtocolErr
if ( ! ( ReadRawRC ( ErrorReg ) & 0x1B ) )
{
cStatus = MI_OK;
if ( ucN & ucIrqEn & 0x01 ) //是否发生定时器中断
cStatus = MI_NOTAGERR;
if ( ucCommand == PCD_TRANSCEIVE )
{
//读FIFO中保存的字节数
ucN = ReadRawRC ( FIFOLevelReg );
//最后接收到得字节的有效位数
ucLastBits = ReadRawRC ( ControlReg ) & 0x07;
if ( ucLastBits )
//N个字节数减去1（最后一个字节）+最后一位的位数 读取到的数据总位数
* pOutLenBit = ( ucN - 1 ) * 8 + ucLastBits;
else
* pOutLenBit = ucN * 8; //最后接收到的字节整个字节有效
if ( ucN == 0 )
ucN = 1;
if ( ucN > MAXRLEN )
ucN = MAXRLEN;
for ( ul = 0; ul < ucN; ul ++ )
pOutData [ ul ] = ReadRawRC ( FIFODataReg );
}
}
else
cStatus = MI_ERR;
}
SetBitMask ( ControlReg, 0x80 ); // stop timer now
WriteRawRC ( CommandReg, PCD_IDLE );
return cStatus;
}
/**
* @brief 寻卡
* @param ucReq_code，寻卡方式 = 0x52，寻感应区内所有符合14443A标准的卡；
寻卡方式= 0x26，寻未进入休眠状态的卡
* @param pTagType，卡片类型代码
= 0x4400，Mifare_UltraLight
= 0x0400，Mifare_One(S50)
= 0x0200，Mifare_One(S70)
= 0x0800，Mifare_Pro(X))
= 0x4403，Mifare_DESFire
* @retval 状态值= MI_OK，成功
*/
char PcdRequest ( uint8_t ucReq_code, uint8_t * pTagType )
{
char cStatus;
uint8_t ucComMF522Buf [ MAXRLEN ];
uint32_t ulLen;
//清理指示MIFARECyptol单元接通以及所有卡的数据通信被加密的情况
ClearBitMask ( Status2Reg, 0x08 );
//发送的最后一个字节的 七位
WriteRawRC ( BitFramingReg, 0x07 );
//ClearBitMask ( TxControlReg, 0x03 );
//TX1,TX2管脚的输出信号传递经发送调制的13.56的能量载波信号
//usleep(10000);
//SetBitMask ( TxControlReg, 0x03 );
ucComMF522Buf [ 0 ] = ucReq_code; //存入 卡片命令字
cStatus = PcdComMF522 ( PCD_TRANSCEIVE,
ucComMF522Buf,
1,
ucComMF522Buf,
& ulLen ); //寻卡
if ( ( cStatus == MI_OK ) && ( ulLen == 0x10 ) ) //寻卡成功返回卡类型
{
* pTagType = ucComMF522Buf [ 0 ];
* ( pTagType + 1 ) = ucComMF522Buf [ 1 ];
}
else
cStatus = MI_ERR;
return cStatus;
}
/**
* @brief 防冲撞
* @param pSnr，卡片序列号，4字节
* @retval 状态值= MI_OK，成功
*/
char PcdAnticoll ( uint8_t * pSnr )
{
char cStatus;
uint8_t uc, ucSnr_check = 0;
uint8_t ucComMF522Buf [ MAXRLEN ];
uint32_t ulLen;
//清MFCryptol On位 只有成功执行MFAuthent命令后，该位才能置位
ClearBitMask ( Status2Reg, 0x08 );
//清理寄存器 停止收发
WriteRawRC ( BitFramingReg, 0x00);
//清ValuesAfterColl所有接收的位在冲突后被清除
ClearBitMask ( CollReg, 0x80 );
ucComMF522Buf [ 0 ] = 0x93; //卡片防冲突命令
ucComMF522Buf [ 1 ] = 0x20;
cStatus = PcdComMF522 ( PCD_TRANSCEIVE,
ucComMF522Buf,
2,
ucComMF522Buf,
& ulLen); //与卡片通信
if ( cStatus == MI_OK) //通信成功
{
for ( uc = 0; uc < 4; uc ++ )
{
* ( pSnr + uc ) = ucComMF522Buf [ uc ]; //读出UID
ucSnr_check ^= ucComMF522Buf [ uc ];
}
if ( ucSnr_check != ucComMF522Buf [ uc ] )
cStatus = MI_ERR;
}
SetBitMask ( CollReg, 0x80 );
return cStatus;
}
/**
* @brief 用RC522计算CRC16
* @param pIndata，计算CRC16的数组
* @param ucLen，计算CRC16的数组字节长度
* @param pOutData，存放计算结果存放的首地址
* @retval 无
*/
void CalulateCRC ( uint8_t * pIndata,
uint8_t ucLen,
uint8_t * pOutData )
{
uint8_t uc, ucN;
ClearBitMask(DivIrqReg,0x04);
WriteRawRC(CommandReg,PCD_IDLE);
SetBitMask(FIFOLevelReg,0x80);
for ( uc = 0; uc < ucLen; uc ++)
WriteRawRC ( FIFODataReg, * ( pIndata + uc ) );
WriteRawRC ( CommandReg, PCD_CALCCRC );
uc = 0xFF;
do
{
ucN = ReadRawRC ( DivIrqReg );
uc --;
} while ( ( uc != 0 ) && ! ( ucN & 0x04 ) );
pOutData [ 0 ] = ReadRawRC ( CRCResultRegL );
pOutData [ 1 ] = ReadRawRC ( CRCResultRegM );
}
/**
* @brief 选定卡片
* @param pSnr，卡片序列号，4字节
* @retval 状态值= MI_OK，成功
*/
char PcdSelect ( uint8_t * pSnr )
{
char ucN;
uint8_t uc;
uint8_t ucComMF522Buf [ MAXRLEN ];
uint32_t ulLen;
ucComMF522Buf [ 0 ] = PICC_ANTICOLL1;
ucComMF522Buf [ 1 ] = 0x70;
ucComMF522Buf [ 6 ] = 0;
for ( uc = 0; uc < 4; uc ++ )
{
ucComMF522Buf [ uc + 2 ] = * ( pSnr + uc );
ucComMF522Buf [ 6 ] ^= * ( pSnr + uc );
}
CalulateCRC ( ucComMF522Buf, 7, & ucComMF522Buf [ 7 ] );
ClearBitMask ( Status2Reg, 0x08 );
ucN = PcdComMF522 ( PCD_TRANSCEIVE,
ucComMF522Buf,
9,
ucComMF522Buf,
& ulLen );
if ( ( ucN == MI_OK ) && ( ulLen == 0x18 ) )
ucN = MI_OK;
else
ucN = MI_ERR;
return ucN;
}
/**
* @brief 验证卡片密码
* @param ucAuth_mode，密码验证模式= 0x60，验证A密钥，
密码验证模式= 0x61，验证B密钥
* @param uint8_t ucAddr，块地址
* @param pKey，密码
* @param pSnr，卡片序列号，4字节
* @retval 状态值= MI_OK，成功
*/
char PcdAuthState ( uint8_t ucAuth_mode,
uint8_t ucAddr,
uint8_t * pKey,
uint8_t * pSnr )
{
char cStatus;
uint8_t uc, ucComMF522Buf [ MAXRLEN ];
uint32_t ulLen;
ucComMF522Buf [ 0 ] = ucAuth_mode;
ucComMF522Buf [ 1 ] = ucAddr;
for ( uc = 0; uc < 6; uc ++ )
ucComMF522Buf [ uc + 2 ] = * ( pKey + uc );
for ( uc = 0; uc < 6; uc ++ )
ucComMF522Buf [ uc + 8 ] = * ( pSnr + uc );
cStatus = PcdComMF522 ( PCD_AUTHENT,
ucComMF522Buf,
12,
ucComMF522Buf,
& ulLen );
if ( ( cStatus != MI_OK ) || ( ! ( ReadRawRC ( Status2Reg ) & 0x08 ) ) )
cStatus = MI_ERR;
return cStatus;
}
/**
* @brief 写数据到M1卡一块
* @param uint8_t ucAddr，块地址
* @param pData，写入的数据，16字节
* @retval 状态值= MI_OK，成功
*/
char PcdWrite ( uint8_t ucAddr, uint8_t * pData )
{
char cStatus;
uint8_t uc, ucComMF522Buf [ MAXRLEN ];
uint32_t ulLen;
ucComMF522Buf [ 0 ] = PICC_WRITE;
ucComMF522Buf [ 1 ] = ucAddr;
CalulateCRC ( ucComMF522Buf, 2, & ucComMF522Buf [ 2 ] );
cStatus = PcdComMF522 ( PCD_TRANSCEIVE,
ucComMF522Buf,
4,
ucComMF522Buf,
& ulLen );
if ( ( cStatus != MI_OK ) || ( ulLen != 4 ) ||
( ( ucComMF522Buf [ 0 ] & 0x0F ) != 0x0A ) )
cStatus = MI_ERR;
if ( cStatus == MI_OK )
{
//memcpy(ucComMF522Buf, pData, 16);
for ( uc = 0; uc < 16; uc ++ )
ucComMF522Buf [ uc ] = * ( pData + uc );
CalulateCRC ( ucComMF522Buf, 16, & ucComMF522Buf [ 16 ] );
cStatus = PcdComMF522 ( PCD_TRANSCEIVE,
ucComMF522Buf,
18,
ucComMF522Buf,
& ulLen );
if ( ( cStatus != MI_OK ) || ( ulLen != 4 ) ||
( ( ucComMF522Buf [ 0 ] & 0x0F ) != 0x0A ) )
cStatus = MI_ERR;
}
return cStatus;
}
/**
* @brief 读取M1卡一块数据
* @param ucAddr，块地址
* @param pData，读出的数据，16字节
* @retval 状态值= MI_OK，成功
*/
char PcdRead ( uint8_t ucAddr, uint8_t * pData )
{
char cStatus;
uint8_t uc, ucComMF522Buf [ MAXRLEN ];
uint32_t ulLen;
ucComMF522Buf [ 0 ] = PICC_READ;
ucComMF522Buf [ 1 ] = ucAddr;
CalulateCRC ( ucComMF522Buf, 2, & ucComMF522Buf [ 2 ] );
cStatus = PcdComMF522 ( PCD_TRANSCEIVE,
ucComMF522Buf,
4,
ucComMF522Buf,
& ulLen );
if ( ( cStatus == MI_OK ) && ( ulLen == 0x90 ) )
{
for ( uc = 0; uc < 16; uc ++ )
* ( pData + uc ) = ucComMF522Buf [ uc ];
}
else
cStatus = MI_ERR;
return cStatus;
}
/**
* @brief 命令卡片进入休眠状态
* @param 无
* @retval 状态值= MI_OK，成功
*/
char PcdHalt( void )
{
uint8_t ucComMF522Buf [ MAXRLEN ];
uint32_t ulLen;
ucComMF522Buf [ 0 ] = PICC_HALT;
ucComMF522Buf [ 1 ] = 0;
CalulateCRC ( ucComMF522Buf, 2, & ucComMF522Buf [ 2 ] );
PcdComMF522 ( PCD_TRANSCEIVE,
ucComMF522Buf,
4,
ucComMF522Buf,
& ulLen );
return MI_OK;
}
void IC_CMT ( uint8_t * UID,
uint8_t * KEY,
uint8_t RW,
uint8_t * Dat )
{
uint8_t ucArray_ID [ 4 ] = { 0 }; //先后存放IC卡的类型和UID(IC卡序列号)
PcdRequest ( 0x52, ucArray_ID ); //寻卡
PcdAnticoll ( ucArray_ID ); //防冲撞
PcdSelect ( UID ); //选定卡
PcdAuthState ( 0x60, 0x10, KEY, UID );//校验
if ( RW ) //读写选择，1是读，0是写
PcdRead ( 0x10, Dat );
else
PcdWrite ( 0x10, Dat );
PcdHalt ();
}
void IC_Read_Or_Write(uint8_t flag, unsigned char *WriteData, uint8_t *readValue)
{
uint8_t KeyValue[]={0xFF ,0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; // 卡A密钥
// u8 status = 0;
char cStr [ 30 ];
uint8_t ucArray_ID [ 4 ]; /*先后存放IC卡的类型和UID(IC卡序列号)*/
uint8_t ucStatusReturn; /*返回状态*/
/*寻卡*/
if ( ( ucStatusReturn = PcdRequest ( PICC_REQIDL, ucArray_ID ) ) != MI_OK )
{
/*若失败再次寻卡*/
ucStatusReturn = PcdRequest ( PICC_REQIDL, ucArray_ID );
//printf("ucStatusReturn: %d\n", ucStatusReturn);
}
if ( ucStatusReturn == MI_OK )
{
/*防冲撞（当有多张卡进入读写器操作范围时，防冲突机制会从其中选择一张进行操作）*/
if ( PcdAnticoll ( ucArray_ID ) == MI_OK )
{
printf("select card\n");
PcdSelect(ucArray_ID); // 选卡
ucStatusReturn = PcdAuthState( PICC_AUTHENT1A, 0x11, KeyValue, ucArray_ID );//校验密码
if(ucStatusReturn == MI_OK)
printf("compare password\n");
if (flag == WriteFlag)
PcdWrite(0x11, WriteData);
if (PcdRead(0x11, readValue) != MI_OK)
{
printf("read err!\r\n");
}
else
{
sprintf ( cStr, "The Card ID is: %02X%02X%02X%02X",ucArray_ID [0], ucArray_ID [1], ucArray_ID [2],ucArray_ID [3] );
printf ( "%s\r\n",cStr ); //打印卡片ID
printf ("readValue: %s\r\n",readValue);
PcdHalt();
}
}
}
}
static unsigned char mode = 0; /* write : mode = 0, read : mode = 1*/
static pthread_cond_t mode_cond = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t mode_mutex = PTHREAD_MUTEX_INITIALIZER;
#if 0
static void *IC_Select_Thread_Func(void *arg)
{
unsigned char write_value = 100;
unsigned char read_value;
char cStr[30];
while(1)
{
unsigned char ucStatusReturn; /*返回状态*/
unsigned char KeyValue[]={0xFF ,0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; // 卡A密钥
unsigned char ucArray_ID [ 4 ]; /*先后存放IC卡的类型和UID(IC卡序列号)*/
ucStatusReturn = PcdRequest(PICC_REQIDL, ucArray_ID);
if(ucStatusReturn == MI_OK)
{
/*防冲撞（当有多张卡进入读写器操作范围时，防冲突机制会从其中选择一张进行操作）*/
ucStatusReturn = PcdAnticoll(ucArray_ID);
if (ucStatusReturn == MI_OK)
{
printf("select card!\n");
/* 操作选中的卡 */
PcdSelect(ucArray_ID);
/* 校验密码 */
ucStatusReturn = PcdAuthState( PICC_AUTHENT1A, 0x11, KeyValue, ucArray_ID );
if(ucStatusReturn == MI_OK)
{
/* 读卡 : mode = 1, 写卡 : mode = 1*/
mode = 1;
}
if(mode)
{
if(PcdRead(0x11, &read_value) != MI_OK)
printf("read err!\n");
else
{
sprintf ( cStr, "The Card ID is: %02X%02X%02X%02X",ucArray_ID [0], ucArray_ID [1], ucArray_ID [2],ucArray_ID [3] );
printf ( "%s\r\n",cStr ); //打印卡片ID
printf ("readValue: %d\r\n",read_value);
PcdHalt();
}
}
else
{
ucStatusReturn = PcdWrite(0x11, &write_value);
if(ucStatusReturn == MI_OK)
printf("write sucess!\n");
else
printf("write err!\n");
}
}
}
else
ucStatusReturn = PcdRequest(PICC_REQIDL, ucArray_ID);
sleep(1);
}
}
#endif
#if 0
void my_test(void)
{
pthread_t IC_Select_Thread;
int ret;
ret = pthread_create(&IC_Select_Thread, NULL, IC_Select_Thread_Func, NULL);
if(ret != 0)
printf("pthread_create IC_Select_Thread err!\n");
}
#endif
void test(void)
{
uint8_t readdata[30] = { 0 };
uint32_t times = 0;
/*RC522模块所需外设的初始化配置*/
// rc522_init ();
// printk ( "WF-RC522 Test\n" );
// PcdReset ();
// /*设置工作方式*/
// M500PcdConfigISOType ( 'A' );
while (1)
{
IC_Read_Or_Write(ReadFlag, NULL, readdata);
// printf("%s %s %d\r\n", __FILE__, __FUNCTION__, __LINE__);
// printf("main func read is %s\r\n", readdata);
times++;
if (times >= 100000)
memset (readdata, 0, sizeof(readdata));
}
}
2.rc522_app.h
#ifndef _RC522_H
#define _RC522_H
#include <stdint.h>
/*
//MF522命令字
*/
#define PCD_IDLE 0x00 //取消当前命令
#define PCD_AUTHENT 0x0E //验证密钥
#define PCD_RECEIVE 0x08 //接收数据
#define PCD_TRANSMIT 0x04 //发送数据
#define PCD_TRANSCEIVE 0x0C //发送并接收数据
#define PCD_RESETPHASE 0x0F //复位
#define PCD_CALCCRC 0x03 //CRC计算
/*
//Mifare_One卡片命令字
*/
#define PICC_REQIDL 0x26 //寻天线区内未进入休眠状态
#define PICC_REQALL 0x52 //寻天线区内全部卡
#define PICC_ANTICOLL1 0x93 //防冲撞
#define PICC_ANTICOLL2 0x95 //防冲撞
#define PICC_AUTHENT1A 0x60 //验证A密钥
#define PICC_AUTHENT1B 0x61 //验证B密钥
#define PICC_READ 0x30 //读块
#define PICC_WRITE 0xA0 //写块
#define PICC_DECREMENT 0xC0 //扣款
#define PICC_INCREMENT 0xC1 //充值
#define PICC_RESTORE 0xC2 //调块数据到缓冲区
#define PICC_TRANSFER 0xB0 //保存缓冲区中数据
#define PICC_HALT 0x50 //休眠
/*
//MF522 FIFO长度定义
*/
#define DEF_FIFO_LENGTH 64 //FIFO size=64byte
#define MAXRLEN 18
/*
//MF522寄存器定义
/
// PAGE 0
*/
#define RFU00 0x00
#define CommandReg 0x01
#define ComIEnReg 0x02
#define DivlEnReg 0x03
#define ComIrqReg 0x04
#define DivIrqReg 0x05
#define ErrorReg 0x06
#define Status1Reg 0x07
#define Status2Reg 0x08
#define FIFODataReg 0x09
#define FIFOLevelReg 0x0A
#define WaterLevelReg 0x0B
#define ControlReg 0x0C
#define BitFramingReg 0x0D
#define CollReg 0x0E
#define RFU0F 0x0F
/*PAGE 1*/
#define RFU10 0x10
#define ModeReg 0x11
#define TxModeReg 0x12
#define RxModeReg 0x13
#define TxControlReg 0x14
#define TxAutoReg 0x15
#define TxSelReg 0x16
#define RxSelReg 0x17
#define RxThresholdReg 0x18
#define DemodReg 0x19
#define RFU1A 0x1A
#define RFU1B 0x1B
#define MifareReg 0x1C
#define RFU1D 0x1D
#define RFU1E 0x1E
#define SerialSpeedReg 0x1F
/*PAGE 2*/
#define RFU20 0x20
#define CRCResultRegM 0x21
#define CRCResultRegL 0x22
#define RFU23 0x23
#define ModWidthReg 0x24
#define RFU25 0x25
#define RFCfgReg 0x26
#define GsNReg 0x27
#define CWGsCfgReg 0x28
#define ModGsCfgReg 0x29
#define TModeReg 0x2A
#define TPrescalerReg 0x2B
#define TReloadRegH 0x2C
#define TReloadRegL 0x2D
#define TCounterValueRegH 0x2E
#define TCounterValueRegL 0x2F
/*PAGE 3 */
#define RFU30 0x30
#define TestSel1Reg 0x31
#define TestSel2Reg 0x32
#define TestPinEnReg 0x33
#define TestPinValueReg 0x34
#define TestBusReg 0x35
#define AutoTestReg 0x36
#define VersionReg 0x37
#define AnalogTestReg 0x38
#define TestDAC1Reg 0x39
#define TestDAC2Reg 0x3A
#define TestADCReg 0x3B
#define RFU3C 0x3C
#define RFU3D 0x3D
#define RFU3E 0x3E
#define RFU3F 0x3F
/*
//和MF522通讯时返回的错误代码
*/
#define MI_OK 0x26
#define MI_NOTAGERR 0xcc
#define MI_ERR 0xbb
void test(void);
#endif3.rc522_test.c
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <asm/ioctls.h>
#include <unistd.h>
#include <stdint.h>
#include "rc522_app.h"
int main(int argc, const char * argv [ ])
{
int ret = -1;
uint8_t buf[2];
ret = PcdReset();
if(ret != 0)
{
printf("rc522 rst error %d \n",ret);
return 0;
}
M500PcdConfigISOType ( 'A' );
test();
while(1)
{
}
}
4.Makefile
# 1. 使用不同的开发板内核时, 一定要修改KERN_DIR
# 2. KERN_DIR中的内核要事先配置、编译, 为了能编译内核, 要先设置下列环境变量:
# 2.1 ARCH, 比如: export ARCH=arm64
# 2.2 CROSS_COMPILE, 比如: export CROSS_COMPILE=aarch64-linux-gnu-
# 2.3 PATH, 比如: export PATH=$PATH:/home/book/100ask_roc-rk3399-pc/ToolChain-6.3.1/gcc-linaro-6.3.1-2017.05-x86_64_aarch64-linux-gnu/bin
# 注意: 不同的开发板不同的编译器上述3个环境变量不一定相同,
# 请参考各开发板的高级用户使用手册
KERN_DIR = /home/book/100ask_imx6ull-sdk/Linux-4.9.88 # 板子所用内核源码的目录
Target=rc522_test
objects=rc522_test.c rc522_app.c
all:$(objects)
make -C $(KERN_DIR) M=`pwd` modules
$(CROSS_COMPILE)gcc -o $(Target) $^ -lpthread
clean:
make -C $(KERN_DIR) M=`pwd` modules clean
rm -rf modules.order $(Target)
# 参考内核源码drivers/char/ipmi/Makefile
# 要想把a.c, b.c编译成ab.ko, 可以这样指定:
# ab-y := a.o b.o
# obj-m += ab.o
obj-m += rc522_spidrv.o
再次感谢那位大佬的文章，我向他提问，他也非常耐心的回答我的问题，非常感谢。