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);
};

mode_bits值会在spi.c中做判断：

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];
}

spi_board_info信息注册时候创建一个spi_device，代码入下：

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><default><default><1>
spi_cs1             = port:PB13<1><default><default><1>
spi_sclk            = port:PC20<1><default><default><default>
spi_mosi            = port:PC21<1><default><default><default>
spi_miso            = port:PC22<0><default><default><default>
spi_enable          = port:PB05<1><default><default><1>

[spi_board1]
manual_cs               = port:PI07<1><default><default><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 <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/input.h>
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/delay.h>
#include <linux/miscdevice.h>
#include <linux/platform_device.h>
#include <asm/uaccess.h>
#include <linux/device.h>
#include <linux/interrupt.h>
#include <linux/mutex.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <mach/gpio.h>
#include <linux/gpio.h>
#include <mach/a20_config.h>
#include <linux/timer.h>
#include <linux/sched.h>
#include <linux/version.h>
#include <linux/semaphore.h>
#include <mach/sys_config.h>
#include <linux/platform_device.h>
#include <linux/spi/spi.h>
#include <linux/spi/spi_gpio.h>
#include <linux/spi/spi_bitbang.h>

#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的长度和内容即可。