SPI驱动之SPI设备驱动程序

前篇文章分析了SPI主控制器驱动，也就是SPI总线驱动，既然总线有了，根据Linux设备驱动模型，还得有SPI设备和SPI设备驱动。SPI设备是在板级文件中注册，SPI设备驱动需要用户自己实现，好在内核为我们提供了一个通用的SPI设备驱动spidev.c，下面就来分析一下这个文件，该文件位于kernel3.0.15/drivers/spi/spidev.c。

1. 模块初始化和注销：spidev_init & spidev_exit

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.
	 */
	.write =	spidev_write,
	.read =		spidev_read,
	.unlocked_ioctl = spidev_ioctl,
	.compat_ioctl = spidev_compat_ioctl,
	.open =		spidev_open,
	.release =	spidev_release,
	.llseek =	no_llseek,
};

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.
	 */
};
 
/*-------------------------------------------------------------------------*/
 
static int __init spidev_init(void)
{
	int status;
 
	/* Claim our 256 reserved device numbers.  Then register a class
	 * that will key udev/mdev to add/remove /dev nodes.  Last, register
	 * the driver which manages those device numbers.
	 */
	BUILD_BUG_ON(N_SPI_MINORS > 256);
	//注册字符设备，参数spidev_fops是struct file_operations的实例，这里就可以知道，用户程序的open、write等操作最终会调用这里面的函数
	status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);
	if (status < 0)
		return status;
 
	spidev_class = class_create(THIS_MODULE, "spidev"); //创建spidev这一类设备，为后面自动生成设备节点做准备
	if (IS_ERR(spidev_class)) {
		unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
		return PTR_ERR(spidev_class);
	}
 
	status = spi_register_driver(&spidev_spi_driver); //注册spi设备驱动
	if (status < 0) {
		class_destroy(spidev_class);
		unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
	}
	return status;
}
module_init(spidev_init);
 
static void __exit spidev_exit(void)
{
	spi_unregister_driver(&spidev_spi_driver);
	class_destroy(spidev_class);
	unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
}
module_exit(spidev_exit);
 
MODULE_AUTHOR("Andrea Paterniani, <a.paterniani@swapp-eng.it>");
MODULE_DESCRIPTION("User mode SPI device interface");
MODULE_LICENSE("GPL");
MODULE_ALIAS("spi:spidev");

在模块初始化函数中，创建了一个字符设备以提供API给用户层，同时创建了一个spidev类，最后注册spi_driver到内核中。在这里我们看到了SPI设备驱动是如何提供API给用户层的，那就是通过再熟悉不过的字符设备。通过字符设备，给用户层提供了5个API：open，release，write，read和ioctl。

接下来分析一下spi_register_driver函数，该函数位于kernel3.0.15/drivers/spi/spi.c

int spi_register_driver(struct spi_driver *sdrv)
{
	sdrv->driver.bus = &spi_bus_type; //该驱动所属的总线
	if (sdrv->probe)
		sdrv->driver.probe = spi_drv_probe;
	if (sdrv->remove)
		sdrv->driver.remove = spi_drv_remove;
	if (sdrv->shutdown)
		sdrv->driver.shutdown = spi_drv_shutdown;
	//将驱动注册进设备模型，注册成功的话就会在总线上寻找设备，调用总线上的match函数，看能否与之匹配起来，匹配成功的话，驱动中的probe函数就会被调用
	return driver_register(&sdrv->driver);
}

在调用driver_register的过程中，将用driver.name和spi_device的modalias字段进行比较，两者相等则将该spi_driver和spi_device进行绑定。当spi_driver注册成功以后，将调用probe方法：spidev_probe函数。

2. 探测和移除函数：spidev_probe & spidev_remove

static int __devinit spidev_probe(struct spi_device *spi)
{
	struct spidev_data	*spidev;
	int			status;
	unsigned long		minor;
 
	/* Allocate driver data */
	spidev = kzalloc(sizeof(*spidev), GFP_KERNEL); //分配内存，注意对象的类型是struct spidev_data
	if (!spidev)
		return -ENOMEM;
 
	/* Initialize the driver data */
	spidev->spi = spi;
	spin_lock_init(&spidev->spi_lock); //一些锁和链表的初始化
	mutex_init(&spidev->buf_lock);
 
	INIT_LIST_HEAD(&spidev->device_entry);
 
	/* If we can allocate a minor number, hook up this device.
	 * Reusing minors is fine so long as udev or mdev is working.
	 */
	mutex_lock(&device_list_lock);
	minor = find_first_zero_bit(minors, N_SPI_MINORS); //从名字上就可以知道，就是找到第一个为0的位，分析见下面
	if (minor < N_SPI_MINORS) {
		struct device *dev;
 
		spidev->devt = MKDEV(SPIDEV_MAJOR, minor); //如果找到了非0位，就将它作为次设备号与之前注册的主设备号生成设备号
		dev = device_create(spidev_class, &spi->dev, spidev->devt,//创建设备，并生成设备节点，设备节点在/dev目录下，名字的形式为“spidevx.x”
				    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) { //创建设备成功后，将相应的位置1，表示该次设备号已经被使用，同时将该设备加入到设备链表
		set_bit(minor, minors);
		list_add(&spidev->device_entry, &device_list);
	}
	mutex_unlock(&device_list_lock);
 
	if (status == 0)
		spi_set_drvdata(spi, spidev); //将设备的私有数据指针指向该设备
	else
		kfree(spidev);
 
	return status;
}
 
static int __devexit spidev_remove(struct spi_device *spi)
{
	struct spidev_data	*spidev = spi_get_drvdata(spi);
 
	/* make sure ops on existing fds can abort cleanly */
	spin_lock_irq(&spidev->spi_lock);
	spidev->spi = NULL;
	spi_set_drvdata(spi, NULL);
	spin_unlock_irq(&spidev->spi_lock);
 
	/* prevent new opens */
	mutex_lock(&device_list_lock);
	list_del(&spidev->device_entry);
	device_destroy(spidev_class, spidev->devt);
	clear_bit(MINOR(spidev->devt), minors);
	if (spidev->users == 0)
		kfree(spidev);
	mutex_unlock(&device_list_lock);
 
	return 0;
}

spidev_data(kernel3.0.15/driver/spi/spidev.c)

struct spidev_data {
	dev_t			devt; //设备号
	spinlock_t		spi_lock;
	struct spi_device	*spi;
	struct list_head	device_entry; //设备链表，所有采用此驱动的设备将连成一个链表
 
	/* buffer is NULL unless this device is open (users > 0) */
	struct mutex		buf_lock;
	unsigned		users; //计数，也即是此设备被open的次数
	u8			*buffer;
};

find_first_zero_bit(minors, N_SPI_MINORS)
第一个参数minors的定义：

kernel3.0.15/driver/spi/spidev.c

#define N_SPI_MINORS			32	/* ... up to 256 */
 
static DECLARE_BITMAP(minors, N_SPI_MINORS);

DECLARE_BITMAP是一个宏，定义如下：

kernel3.0.15/include/linux/types.h

#define DECLARE_BITMAP(name,bits) \
	unsigned long name[BITS_TO_LONGS(bits)]

将宏展开后是这样的，unsigned long minors[1]，其实就是定义一个只有一个元素的无符号长整形数组miniors。

3. 打开和释放函数：spidev_open & spidev_release

static int spidev_open(struct inode *inode, struct file *filp)
{
	struct spidev_data	*spidev;
	int			status = -ENXIO;
 
	mutex_lock(&device_list_lock);
 
	list_for_each_entry(spidev, &device_list, device_entry) {
		if (spidev->devt == inode->i_rdev) { //遍历设备链表，每找到一个设备就将它的设备号与打开文件的设备号进行比较，相等的话表示查找成功
			status = 0;
			break;
		}
	}
	//查找成功后就分配读写数据内存，使用计数加1，设置文件私有数据指针指向查找到的设备，以后在驱动的write、read函数里就可以把它取出来
	if (status == 0) {
		if (!spidev->buffer) {
			spidev->buffer = kmalloc(bufsiz, GFP_KERNEL);
			if (!spidev->buffer) {
				dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
				status = -ENOMEM;
			}
		}
		if (status == 0) {
			spidev->users++;
			filp->private_data = spidev;
			nonseekable_open(inode, filp);
		}
	} else
		pr_debug("spidev: nothing for minor %d\n", iminor(inode));
 
	mutex_unlock(&device_list_lock);
	return status;
}
 
static int spidev_release(struct inode *inode, struct file *filp)
{
	struct spidev_data	*spidev;
	int			status = 0;
 
	mutex_lock(&device_list_lock);
	spidev = filp->private_data;
	filp->private_data = NULL;
 
	/* last close? */
	spidev->users--;
	if (!spidev->users) {
		int		dofree;
 
		kfree(spidev->buffer);
		spidev->buffer = NULL;
 
		/* ... after we unbound from the underlying device? */
		spin_lock_irq(&spidev->spi_lock);
		dofree = (spidev->spi == NULL);
		spin_unlock_irq(&spidev->spi_lock);
 
		if (dofree)
			kfree(spidev);
	}
	mutex_unlock(&device_list_lock);
 
	return status;
}

4. 读和写函数：spidev_read & spidev_write

/* Read-only message with current device setup */
static ssize_t
spidev_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
	struct spidev_data	*spidev;
	ssize_t			status = 0;
 
	/* chipselect only toggles at start or end of operation */
	if (count > bufsiz)
		return -EMSGSIZE;
 
	spidev = filp->private_data;
 
	mutex_lock(&spidev->buf_lock);
	status = spidev_sync_read(spidev, count);
	if (status > 0) {
		unsigned long	missing;
 
		missing = copy_to_user(buf, spidev->buffer, status);
		if (missing == status)
			status = -EFAULT;
		else
			status = status - missing;
	}
	mutex_unlock(&spidev->buf_lock);
 
	return status;
}
 
/* Write-only message with current device setup */
static ssize_t
spidev_write(struct file *filp, const char __user *buf,
		size_t count, loff_t *f_pos)
{
	struct spidev_data	*spidev;
	ssize_t			status = 0;
	unsigned long		missing;
 
	/* chipselect only toggles at start or end of operation */
	if (count > bufsiz) //应用程序写入的数据不能大于驱动中缓冲区的大小，默认为4096个字节
		return -EMSGSIZE;
 
	spidev = filp->private_data; //指向文件的私有数据
 
	mutex_lock(&spidev->buf_lock);
	missing = copy_from_user(spidev->buffer, buf, count); //拷贝用户空间的数据到内核空间
	if (missing == 0) {
		status = spidev_sync_write(spidev, count);
	} else
		status = -EFAULT;
	mutex_unlock(&spidev->buf_lock);
 
	return status;
}

5.ioctl函数：spidev_ioctl