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