linux SPI驱动 - 模拟gpio
用A20的芯片做一个项目，rfid和单片机都用spi通讯，挂在同样个spi控制器上，A20的每个spi控制器刚好支持最多两个从设备，但是好像平台的代码有问题还是别的原因，只有rfid可以通讯，单片机的spi始终没有反应，不得已改用gpio模拟，幸好内核有现成的模拟gpio代码,把它配置起来用即可。
不过我以前没有用过，所以花了半天时间分析里面的代码结构才写好驱动代码。
重要的结构体分析：
struct spi_master {
struct device dev;
struct list_head list;
/* other than negative (== assign one dynamically), bus_num is fully
* board-specific. usually that simplifies to being SOC-specific.
* example: one SOC has three SPI controllers, numbered 0..2,
* and one board's schematics might show it using SPI-2. software
* would normally use bus_num=2 for that controller.
*/
s16 bus_num;//给自己的编号，设备驱动中的编号和这里一样，表示用的是该控制器
/* chipselects will be integral to many controllers; some others
* might use board-specific GPIOs.
*/
u16 num_chipselect;//如果芯片带有spi 控制器，一般片选脚集成在控制器中了，如A10每个spi控制器支持两个片选；如果是模拟的控制器，不受限制，可以多个
/* some SPI controllers pose alignment requirements on DMAable
* buffers; let protocol drivers know about these requirements.
*/
u16 dma_alignment;
/* spi_device.mode flags understood by this controller driver */
u16 mode_bits; //该控制器支持的传输模式，比如A10的支持SPI_CPOL | SPI_CPHA | SPI_CS_HIGH | SPI_LSB_FIRST，设备驱动中的传输模式必须在该范围
/* other constraints relevant to this driver */
u16 flags;
#define SPI_MASTER_HALF_DUPLEX BIT(0) /* can't do full duplex */
#define SPI_MASTER_NO_RX BIT(1) /* can't do buffer read */
#define SPI_MASTER_NO_TX BIT(2) /* can't do buffer write */
/* lock and mutex for SPI bus locking */
spinlock_t bus_lock_spinlock;
struct mutex bus_lock_mutex;
/* flag indicating that the SPI bus is locked for exclusive use */
bool bus_lock_flag;
/* Setup mode and clock, etc (spi driver may call many times).
*
* IMPORTANT: this may be called when transfers to another
* device are active. DO NOT UPDATE SHARED REGISTERS in ways
* which could break those transfers.
*/
int (*setup)(struct spi_device *spi);//传输的一些准备工作，控制器自己实现
/* bidirectional bulk transfers
*
* + The transfer() method may not sleep; its main role is
* just to add the message to the queue.
* + For now there's no remove-from-queue operation, or
* any other request management
* + To a given spi_device, message queueing is pure fifo
*
* + The master's main job is to process its message queue,
* selecting a chip then transferring data
* + If there are multiple spi_device children, the i/o queue
* arbitration algorithm is unspecified (round robin, fifo,
* priority, reservations, preemption, etc)
*
* + Chipselect stays active during the entire message
* (unless modified by spi_transfer.cs_change != 0).
* + The message transfers use clock and SPI mode parameters
* previously established by setup() for this device
*/
int (*transfer)(struct spi_device *spi,
struct spi_message *mesg);//最终的传输函数，控制器自己实现
/* called on release() to free memory provided by spi_master */
void (*cleanup)(struct spi_device *spi);
/*
* These hooks are for drivers that want to use the generic
* master transfer queueing mechanism. If these are used, the
* transfer() function above must NOT be specified by the driver.
* Over time we expect SPI drivers to be phased over to this API.
*/
bool queued;
struct kthread_worker kworker;
struct task_struct *kworker_task;
struct kthread_work pump_messages;
spinlock_t queue_lock;
struct list_head queue;
struct spi_message *cur_msg;
bool busy;
bool running;
bool rt;
int (*prepare_transfer_hardware)(struct spi_master *master);
int (*transfer_one_message)(struct spi_master *master,
struct spi_message *mesg);
int (*unprepare_transfer_hardware)(struct spi_master *master);
};
bad_bits = spi->mode & ~spi->master->mode_bits;
if (bad_bits) {
dev_err(&spi->dev, "setup: unsupported mode bits %x\n",
bad_bits);
return -EINVAL;
} 可见，具体的spi设备的mode必须是控制器所支持的，否则错误（模式为0都支持），比如一般片选是0有效，1无效，如果某个设备相反1有效0无效，则该设备驱动中mode位要设置为SPI_CS_HIGH。
struct spi_board_info {
/* the device name and module name are coupled, like platform_bus;
* "modalias" is normally the driver name.
*
* platform_data goes to spi_device.dev.platform_data,
* controller_data goes to spi_device.controller_data,
* irq is copied too
*/
char modalias[SPI_NAME_SIZE]; //设备名字，和驱动中要对应
const void *platform_data;
void *controller_data;//在模拟的控制器中，如果有cs要控制，则为cs对应的gpio
int irq;
/* slower signaling on noisy or low voltage boards */
u32 max_speed_hz;//最大传输速率
/* bus_num is board specific and matches the bus_num of some
* spi_master that will probably be registered later.
*
* chip_select reflects how this chip is wired to that master;
* it's less than num_chipselect.
*/
u16 bus_num; //挂载那个控制器上，和master中的对应
u16 chip_select; //选择那个引脚作为cs控制脚
/* mode becomes spi_device.mode, and is essential for chips
* where the default of SPI_CS_HIGH = 0 is wrong.
*/
u8 mode; //传输模式，
/* ... may need additional spi_device chip config data here.
* avoid stuff protocol drivers can set; but include stuff
* needed to behave without being bound to a driver:
* - quirks like clock rate mattering when not selected
*/
};
对于controller_data值的使用，在spi-gpio.c中如下：
static void spi_gpio_chipselect(struct spi_device *spi, int is_active)
{
unsigned long cs = (unsigned long) spi->controller_data;
/* set initial clock polarity */
if (is_active)
setsck(spi, spi->mode & SPI_CPOL);
if (cs != SPI_GPIO_NO_CHIPSELECT) {
/* SPI is normally active-low */
gpio_set_value(cs, (spi->mode & SPI_CS_HIGH) ? is_active : !is_active);
}
}
struct spi_device {
struct device dev;//每个spi设备对应一个，和device_drvier匹配
struct spi_master *master; //对应的控制器，根据bus_num匹配
u32 max_speed_hz;
u8 chip_select;
u8 mode;
#define SPI_CPHA 0x01 /* clock phase */
#define SPI_CPOL 0x02 /* clock polarity */
#define SPI_MODE_0 (0|0) /* (original MicroWire) */
#define SPI_MODE_1 (0|SPI_CPHA)
#define SPI_MODE_2 (SPI_CPOL|0)
#define SPI_MODE_3 (SPI_CPOL|SPI_CPHA)
#define SPI_CS_HIGH 0x04 /* chipselect active high? */
#define SPI_LSB_FIRST 0x08 /* per-word bits-on-wire */
#define SPI_3WIRE 0x10 /* SI/SO signals shared */
#define SPI_LOOP 0x20 /* loopback mode */
#define SPI_NO_CS 0x40 /* 1 dev/bus, no chipselect */
#define SPI_READY 0x80 /* slave pulls low to pause */
u8 bits_per_word;
int irq;
void *controller_state;
void *controller_data;
char modalias[SPI_NAME_SIZE];
}struct spi_device *spi_new_device(struct spi_master *master,
struct spi_board_info *chip)
{
struct spi_device *proxy;
int status;
/* NOTE: caller did any chip->bus_num checks necessary.
*
* Also, unless we change the return value convention to use
* error-or-pointer (not NULL-or-pointer), troubleshootability
* suggests syslogged diagnostics are best here (ugh).
*/
proxy = spi_alloc_device(master);
if (!proxy)
return NULL;
WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias));
proxy->chip_select = chip->chip_select;
proxy->max_speed_hz = chip->max_speed_hz;
proxy->mode = chip->mode;
proxy->irq = chip->irq;
strlcpy(proxy->modalias, chip->modalias, sizeof(proxy->modalias));
proxy->dev.platform_data = (void *) chip->platform_data;
proxy->controller_data = chip->controller_data;
proxy->controller_state = NULL;
status = spi_add_device(proxy);
if (status < 0) {
spi_dev_put(proxy);
return NULL;
}
return proxy;
}
EXPORT_SYMBOL_GPL(spi_new_device);
内核中提供的gpio模拟spi代码在drivers/spi/spi-gpio.c中，传输逻辑控制在spi-bitbang.c中。按照spi-gpio.c的probe函数实现platform_device代码即可使用模拟spi。
分析到这里已经心中有数了，先把平台的spi gpio配置成普通的输入/输出功能：
[spi2_para]
spi_used = 0
spi_cs_bitmap = 3
;--- spi2 mapping0 ---
spi_cs0 = port:PC19<1><1>
spi_cs1 = port:PB13<1><1>
spi_sclk = port:PC20<1>
spi_mosi = port:PC21<1>
spi_miso = port:PC22<0>
spi_enable = port:PB05<1><1>
[spi_board1]
manual_cs = port:PI07<1><1>
因为rfid部分代码已经写好了，不想去动它，所以这里把平台注册的所有代码放到了spi keyboard中来，不过这不妨碍代码运行。代码如下：
/*
* linux/drivers/misc/spi_keyboard_input.c
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define DEVICE_NAME "spikeyboard-input"
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36)
static DECLARE_MUTEX(sem_rw);//init as 1
#else
DEFINE_SEMAPHORE(sem_rw);
#endif
struct spi_device *keyboard_spi;
static struct input_dev * input;
struct workqueue_struct *spikeyboard_wq;
struct work_struct spikeyboard_work;
static volatile int flags = 1;
static char command[3] = {0};
//Set the keycode from 1 - 16
static int spikeyboard_keycode[] = {KEY_0, KEY_1, KEY_2, KEY_3, KEY_4,
KEY_5, KEY_6, KEY_7, KEY_8, KEY_9,
KEY_Q, KEY_ESC, KEY_MINUS, KEY_EQUAL, KEY_BACKSPACE, KEY_TAB};
#define MAX_BUTTON_CNT (sizeof(spikeyboard_keycode)/sizeof(spikeyboard_keycode[0]))
static void report_keyvalue(unsigned char buffer)
{
if (buffer == 0)
buffer = 16;
input_report_key(input, buffer, 1);
input_sync(input);
input_report_key(input, buffer, 0);
input_sync(input);
}
static void spikeyboard_loop_work(struct work_struct *work)
{
unsigned char buf_rx[1], buf_tx[1];
int ret;
buf_tx[0] = 0xaa;
while (flags) {
down(&sem_rw);
buf_rx[0] = -1;
ret = spi_write_then_read(keyboard_spi, buf_tx, 1, buf_rx, 1);
up(&sem_rw);
msleep(20);
if ((ret == 0) && (buf_rx[0] != 0xff))
printk("ret:%x\n", buf_rx[0]);
report_keyvalue(buf_rx[0]);
}
}
static ssize_t spi_keyboard_input_write(struct file *filp, char *buffer,int len)
{
int i, ret = 0;
struct spi_transfer st[4];
struct spi_message msg;
char buf_rx[1];
if (len != sizeof(command)) {
printk("command format err\n");
return -EFAULT;
}
if (copy_from_user(command, buffer, len)) {
printk("%s, copy form user err\n", __func__);
return -EFAULT;
}
down(&sem_rw);
spi_message_init(&msg);
memset(st, 0, sizeof(st));
for (i = 0; i < sizeof(command); i++) {
st[i].tx_buf = &command[i];
st[i].len = 1;
spi_message_add_tail(&st[i], &msg);
}
st[3].rx_buf = buf_rx;
st[3].len = 1;
spi_message_add_tail(&st[3], &msg);
spi_sync(keyboard_spi, &msg);
up(&sem_rw);
msleep(20);
switch (buf_rx[0]) {
case 0x88 :
printk("spi slave respone the command\n");
break;
case 0x99 :
printk("spi slave not respone the commnad\n");
ret = -EBUSY;
break;
default :
printk("spi send command err\n");
ret = -EBUSY;
}
return ret;
}
static int spi_keyboard_input_open(struct inode *inode, struct file *filp)
{
return 0;
}
static int spi_keyboard_input_release(struct inode *inode, struct file *filp)
{
return 0;
}
static int spi_keyboard_probe(struct spi_device *spi)
{
keyboard_spi = spi;
printk("sclu %s, %d\n", __func__, __LINE__);
spikeyboard_wq = create_singlethread_workqueue("spi_keyboard_work");
INIT_WORK(&spikeyboard_work, spikeyboard_loop_work);
queue_work(spikeyboard_wq, &spikeyboard_work);
return 0;
}
static int spi_keyboard_remove(struct spi_device *spi)
{
return 0;
}
static struct file_operations spi_keyboard_dev_fops = {
.owner =THIS_MODULE,
.open =spi_keyboard_input_open,
.write =spi_keyboard_input_write,
.release =spi_keyboard_input_release,
};
static struct miscdevice misc = {
.minor = MISC_DYNAMIC_MINOR,
.name = "spikeyboard-input",
.fops = &spi_keyboard_dev_fops,
};
static struct spi_driver spi_keyboard_driver = {
.probe = spi_keyboard_probe,
.remove = spi_keyboard_remove,
.driver = {
.name = "spi_keyboard",
},
};
static struct spi_board_info rfid_rc522 = {
.modalias = "rfid_rc522",
//.platform_data = &at25df641_info,
.mode = SPI_MODE_0,
.irq = 0,
.max_speed_hz = 12 * 1000 * 1000,
.bus_num = 10,
.chip_select = 0, //模拟gpio用不到该成员,但是挂在模拟设备上的device还是不能重复该编号，因为spi core会判断重复的话就注册失败
};
static struct spi_board_info spi_keyboard = {
.modalias = "spi_keyboard",
//.platform_data = &at25df641_info,
.mode = SPI_MODE_0,
.irq = 0,
.max_speed_hz = 12 * 1000 * 1000,
.bus_num = 10,
.chip_select = 1, //模拟gpio用不到该成员
};
static int spi_gpio_config(char *main_para, char *sub_para){
int ret;
script_item_u list[1];
/* 获取gpio list */
ret = script_get_item(main_para, sub_para, list);
if (SCIRPT_ITEM_VALUE_TYPE_PIO != ret) {
printk("%s: %s get gpio list failed\n",
__func__, sub_para);
return 0;
}
return list[0].gpio.gpio;
}
static struct spi_gpio_platform_data spi_gpio_data = {
.num_chipselect = 2, //模拟gpio可以为多个，如果是spi控制器，配合chip_select一起使用
};
static int init_spi_gpio(void) {
char *p_main = "spi2_para";
char *p_sclk = "spi_sclk";
char *p_miso = "spi_miso";
char *p_mosi = "spi_mosi";
struct spi_gpio_platform_data *p = &spi_gpio_data;
p->sck = spi_gpio_config(p_main, p_sclk);
p->miso = spi_gpio_config(p_main, p_miso);
p->mosi = spi_gpio_config(p_main, p_mosi);
rfid_rc522.controller_data = (void *)spi_gpio_config(p_main, "spi_cs0");
spi_keyboard.controller_data = (void *)spi_gpio_config("spi_board1", "manual_cs");
if (!p->sck || !p->miso || !p->mosi)
return -1;
else
return 0;
}
static struct platform_device spi_gpio_device = {
.name = "spi_gpio",
.id = 10,//spi device的编号，设备的bus_num要和这个对应。spi-core也会自动分配编号
.dev.platform_data = &spi_gpio_data,
};
static int __init spi_keyboard_init(void)
{
int ret;
int i;
input = input_allocate_device();
if(!input)
return -ENOMEM;
set_bit(EV_KEY, input->evbit);
for(i = 0; i < MAX_BUTTON_CNT; i++)
set_bit(spikeyboard_keycode[i], input->keybit);
input->name = "spikeyboard-input";
input->phys = "spikeyboard-input/input0";
input->id.bustype = BUS_HOST;
input->id.vendor = 0x0001;
input->id.product = 0x0001;
input->id.version = 0x0100;
input->keycode = spikeyboard_keycode;
if(input_register_device(input) != 0)
{
printk("spi_keyboard-input input register device fail!!\n");
input_free_device(input);
return -ENODEV;
}
ret = misc_register(&misc);
printk(DEVICE_NAME "\tinitialized\n");
init_spi_gpio();
platform_device_register(&spi_gpio_device);
if (spi_register_board_info(&rfid_rc522, 1))
printk("register rfid rc522 board info err\n");
else
printk("register rfid rc522 board info success\n");
if (spi_register_board_info(&spi_keyboard, 1))
printk("register spi_keyboard board info err\n");
else
printk("register spi_keyboard board info success\n");
#if 1
ret = spi_register_driver(&spi_keyboard_driver);
if(ret < 0){
printk("register %s fail\n", __FUNCTION__);
return ret;
}
#endif
return ret;
}
static void __exit spi_keyboard_exit(void)
{
flags = 0;
flush_work_sync(&spikeyboard_work);
destroy_workqueue(spikeyboard_wq);
input_unregister_device(input);
spi_unregister_driver(&spi_keyboard_driver);
misc_deregister(&misc);
platform_device_unregister(&spi_gpio_device);
}
module_init(spi_keyboard_init);
module_exit(spi_keyboard_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("spi_keyboard for A20"); init_spi_gpio();
platform_device_register(&spi_gpio_device);
if (spi_register_board_info(&rfid_rc522, 1))
printk("register rfid rc522 board info err\n");
else
printk("register rfid rc522 board info success\n");
if (spi_register_board_info(&spi_keyboard, 1))
printk("register spi_keyboard board info err\n");
else
printk("register spi_keyboard board info success\n");
ret = spi_register_driver(&spi_keyboard_driver);
if(ret < 0){
printk("register %s fail\n", __FUNCTION__);
return ret;
}
还有要在menuconfig配置中打开spi-gpio.c的配置，这样就可以用模拟spi运行了。同时按键和读写rfid都测试过，速度还是很快的。
和i2c一样，spi子系统也提供了spidev.c驱动让用户空间可以直接操作spi设备；不过有点不同的是，spidev.c中spi_driver的名字固定为"spidev"，所以spi_board_info信息中的名字也要更改成“spidev”才能注册并使用spidev.c提供的方法。下面列出重点部分代码：
static struct spi_driver spidev_spi_driver = {
.driver = {
.name = "spidev",
.owner = THIS_MODULE,
},
.probe = spidev_probe,
.remove = __devexit_p(spidev_remove),
/* 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.
*/
};
定义好驱动后，注册即可：
status = spi_register_driver(&spidev_spi_driver);
这样在匹配成功后调用probe方法：
mutex_lock(&device_list_lock);
minor = find_first_zero_bit(minors, N_SPI_MINORS);
if (minor < N_SPI_MINORS) {
struct device *dev;
spidev->devt = MKDEV(SPIDEV_MAJOR, minor);
dev = device_create(spidev_class, &spi->dev, spidev->devt,
spidev, "spidev%d.%d",
spi->master->bus_num, spi->chip_select);
status = IS_ERR(dev) ? PTR_ERR(dev) : 0;
} else {
dev_dbg(&spi->dev, "no minor number available!\n");
status = -ENODEV;
}
if (status == 0) {
set_bit(minor, minors);
list_add(&spidev->device_entry, &device_list);
}
mutex_unlock(&device_list_lock);
重点是device_create创建了/dev/spidevX.X设备节点，把设备spidev添加到&device_list链表中，以便用户空间用open打开设备节点时候从链表中取出对应的spidev。
一般如果用到spidev.c来提供用户空间的操作函数的话，我们在spi_keyboard.c驱动中就用spi_register_board_info注册好信息即可，无需spi_register_driver注册了，这样就把所有的驱动操作方法搬到用户空间来完成。读写可以用标准的read、write来完成，如果要实现像驱动中的spi_write_then_read，则需要用到ioctl，具体如下。
把驱动中的spi结构体和io 命令复制一份到用户空间，先定义好读写结构：
char tx_buffer[128] = {0x0}, rx_buffer[128] = {0x0};
struct spi_ioc_transfer spi_t[2] = {
{
.tx_buf = tx_buffer,
//.rx_buf = rx_buffer,
.len = 2,
//.speed_hz = 10 * 1000 * 1000,
//.delay_usecs = 10,
//.bits_per_word = 1,
//.cs_change = 0,
//.pad = 0,
},
{
//.tx_buf = tx_buffer,
.rx_buf = rx_buffer,
.len = 15,
.delay_usecs = 10,
}
};spi_ioc_transfer的其他成员不用定义，这样会按照驱动默认值配置。根据自己设备的协议情况，改变tx_buf的内容和长度len、接收的长度len即可。接着：
ret = ioctl(fd, SPI_IOC_MESSAGE(2), spi_t);
if (ret <= 0) {
LOGE("ioctl ret = %d, err = %s", ret, strerror(errno));
}
即可实现等同驱动的spi_write_then_read一次性读写操作，ret返回读写总长度，如上述ret返回15 + 2 = 17。读到的的数据返回在rx_buffer中。
如果要一次多次读写，增加数组spi_t的长度和内容即可。