一、SPI的板级初始化
在板级初始化文件board-am335xevm.c中有对SPI的初始化操作函数spi_init，初始化了SPI引脚和spi_board_info结构体：
static void spi_init(int evm_id, int profile)
{
setup_pin_mux(spi1_pin_mux);
spi_register_board_info(am335x_spi1_slave_info,ARRAY_SIZE(am335x_spi1_slave_info));
return;
}

spi引脚功能初始化：
static struct pinmux_config spi1_pin_mux[] = 
{{"mii1_col.spi1_sclk", OMAP_MUX_MODE2 | AM33XX_PULL_ENBL| AM33XX_INPUT_EN},{"mii1_crs.spi1_d0", OMAP_MUX_MODE2 | AM33XX_PULL_ENBL| AM33XX_PULL_UP | AM33XX_INPUT_EN},{"mii1_rxerr.spi1_d1", OMAP_MUX_MODE2 | AM33XX_PULL_ENBL| AM33XX_INPUT_EN},{"rmii1_refclk.spi1_cs0", OMAP_MUX_MODE2 | AM33XX_PULL_ENBL| AM33XX_PULL_UP | AM33XX_INPUT_EN},{NULL, 0},
};spi_board_info结构体：
static struct spi_board_info am335x_spi1_slave_info[] = {{ .modalias      = "spidev",                         //要匹配SPI驱动的名称.max_speed_hz  = 48000000,   //最高支持的频率.bus_num       = 2,                      //使用的总线控制器.chip_select   = 0,                       //片选数量，，.mode = SPI_MODE_1,             //SPI的工作模式},
};

二、匹配SPI驱动
在spi.c文件中，找到一个spi_driver结构体，
static struct spi_driver spidev_spi_driver = {
.driver = {
.name = “spidev”, //驱动的名称
.owner = THIS_MODULE, //归属
},
.probe = spidev_probe, //匹配函数
.remove = __devexit_p(spidev_remove),
};

这个spi_driver结构体是在spidev_init函数中被调用的：
static int __init spidev_init(void)
{int status;BUILD_BUG_ON(N_SPI_MINORS > 256);     ///它的作用是如果括号内为真则编译出错，，防止出错的一种手段status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);   //注册了一个字符设备，名字叫 ”spi“   这个很重要，后面有用！！！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);   //创建类不成功， 卸载“spi”这个字符设备return PTR_ERR(spidev_class);}status = spi_register_driver(&spidev_spi_driver);   //注册了spi_driver 结构体这个驱动if (status < 0) {class_destroy(spidev_class);   //不成功销毁类unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);   ///注销字符设备}return status;
}最关键的匹配过程在spidev_probe这个函数中实现：
static int __devinit spidev_probe(struct spi_device *spi)
{struct spidev_data *spidev;int   status;unsigned long  minor;spidev = kzalloc(sizeof(*spidev), GFP_KERNEL);   ///在内核空间分配一点内存if (!spidev)return -ENOMEM;spidev->spi = spi;spin_lock_init(&spidev->spi_lock);    //初始化一个自旋锁mutex_init(&spidev->buf_lock);       //初始化一个互斥锁INIT_LIST_HEAD(&spidev->device_entry);   //初始化spidev驱动头节点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);       //老子把设备列表解锁了，你们随便来if (status == 0)spi_set_drvdata(spi, spidev);   ///设置参数elsekfree(spidev);return status;
}

三、SPI设备操作驱动：设备注册完了，该给用户空间提供操作接口了吧
细心的小伙伴会发现在spidev_init函数中有这么个东东：register_chrdev(SPIDEV_MAJOR, “spi”, &spidev_fops);里面的“spi”是谁 和匹配呢？他是和spi的控制器去匹配的，就是spi_board_info中的那个bus_num号，这部分的内容见另一篇文章，这里就不多说了，那还有个spidev_fops结构体是这里的猪脚:
static const struct file_operations spidev_fops = {
.owner = THIS_MODULE, //所有者
.write = spidev_write, //写操作
.read = spidev_read, //读操作
.unlocked_ioctl = spidev_ioctl, //
.compat_ioctl = spidev_compat_ioctl,
.open = spidev_open,
.release = spidev_release,
.llseek = no_llseek,
};

写操作，没什么好说的，直接看代码：
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;if (count > bufsiz)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);     //同步一下消息} elsestatus = -EFAULT;mutex_unlock(&spidev->buf_lock);     ///缓冲区解锁return status;
}spi读操作：
spidev_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{struct spidev_data *spidev;ssize_t   status = 0;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;elsestatus = status - missing;}mutex_unlock(&spidev->buf_lock);     //解锁return status;
}spidev_ioctl函数，最重要的SPI控制函数，对SPI的配置都在这里完成：
spidev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{int   err = 0;int   retval = 0;struct spidev_data *spidev;struct spi_device *spi;u32   tmp;unsigned  n_ioc;struct spi_ioc_transfer *ioc;if (_IOC_TYPE(cmd) != SPI_IOC_MAGIC)    /* Check type and command number */return -ENOTTY;/* Check access direction once here; don't repeat below.* IOC_DIR is from the user perspective, while access_ok is* from the kernel perspective; so they look reversed.*/if (_IOC_DIR(cmd) & _IOC_READ)err = !access_ok(VERIFY_WRITE,  (void __user *)arg, _IOC_SIZE(cmd));if (err == 0 && _IOC_DIR(cmd) & _IOC_WRITE)err = !access_ok(VERIFY_READ,   (void __user *)arg, _IOC_SIZE(cmd));if (err)return -EFAULT;/* guard against device removal before, or while,* we issue this ioctl.*/spidev = filp->private_data;spin_lock_irq(&spidev->spi_lock);     //禁止内核抢占，且关闭本地中断spi = spi_dev_get(spidev->spi);         //获取设备spin_unlock_irq(&spidev->spi_lock);    //解锁if (spi == NULL)return -ESHUTDOWN;/* use the buffer lock here for triple duty:*  - prevent I/O (from us) so calling spi_setup() is safe;*  - prevent concurrent SPI_IOC_WR_* from morphing*    data fields while SPI_IOC_RD_* reads them;*  - SPI_IOC_MESSAGE needs the buffer locked "normally".*/mutex_lock(&spidev->buf_lock);                   //加互斥锁switch (cmd) {/* read requests */case SPI_IOC_RD_MODE:     // 读模式retval = __put_user(spi->mode & SPI_MODE_MASK,  (__u8 __user *)arg);       //内核空间数据传到用户空间break;case SPI_IOC_RD_LSB_FIRST:       //低位在前retval = __put_user((spi->mode & SPI_LSB_FIRST) ?  1 : 0, (__u8 __user *)arg);break;case SPI_IOC_RD_BITS_PER_WORD:       // 读取数据长度retval = __put_user(spi->bits_per_word, (__u8 __user *)arg);break;case SPI_IOC_RD_MAX_SPEED_HZ:      //最大速率retval = __put_user(spi->max_speed_hz, (__u32 __user *)arg);break;case SPI_IOC_WR_MODE:   //写模式retval = __get_user(tmp, (u8 __user *)arg);       /  /用户空间到内核空间if (retval == 0) {u8 save = spi->mode;if (tmp & ~SPI_MODE_MASK) {retval = -EINVAL;break;}tmp |= spi->mode & ~SPI_MODE_MASK;spi->mode = (u8)tmp;retval = spi_setup(spi);   //设置if (retval < 0)spi->mode = save;elsedev_dbg(&spi->dev, "spi mode %02x\n", tmp);}break;case SPI_IOC_WR_LSB_FIRST:   ///低位在前retval = __get_user(tmp, (__u8 __user *)arg);if (retval == 0) {u8 save = spi->mode;if (tmp)spi->mode |= SPI_LSB_FIRST;elsespi->mode &= ~SPI_LSB_FIRST;retval = spi_setup(spi);if (retval < 0)spi->mode = save;elsedev_dbg(&spi->dev, "%csb first\n",  tmp ? 'l' : 'm');}break;case SPI_IOC_WR_BITS_PER_WORD:  //字长retval = __get_user(tmp, (__u8 __user *)arg);if (retval == 0) {u8 save = spi->bits_per_word;spi->bits_per_word = tmp;retval = spi_setup(spi);if (retval < 0)spi->bits_per_word = save;elsedev_dbg(&spi->dev, "%d bits per word\n", tmp);}break;case SPI_IOC_WR_MAX_SPEED_HZ:      //速率retval = __get_user(tmp, (__u32 __user *)arg);if (retval == 0) {u32 save = spi->max_speed_hz;spi->max_speed_hz = tmp;retval = spi_setup(spi);if (retval < 0)spi->max_speed_hz = save;elsedev_dbg(&spi->dev, "%d Hz (max)\n", tmp);}break;default:/* segmented and/or full-duplex I/O request */if (_IOC_NR(cmd) != _IOC_NR(SPI_IOC_MESSAGE(0))  || _IOC_DIR(cmd) != _IOC_WRITE) {retval = -ENOTTY;break;}tmp = _IOC_SIZE(cmd);if ((tmp % sizeof(struct spi_ioc_transfer)) != 0) {retval = -EINVAL;break;}n_ioc = tmp / sizeof(struct spi_ioc_transfer);if (n_ioc == 0)break;ioc = kmalloc(tmp, GFP_KERNEL);if (!ioc) {retval = -ENOMEM;break;}if (__copy_from_user(ioc, (void __user *)arg, tmp)) {kfree(ioc);retval = -EFAULT;break;}retval = spidev_message(spidev, ioc, n_ioc);kfree(ioc);break;}mutex_unlock(&spidev->buf_lock);     /解锁spi_dev_put(spi);     //释放掉return retval;
}设备打开函数：
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;}}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);          ////  不支持文件偏移，不要使用lseek}} elsepr_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;spidev->users--;if (!spidev->users) {int  dofree;kfree(spidev->buffer);spidev->buffer = NULL;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;
}

好了，SPI的驱动到此分析完毕。