linux SPI驅動框架（二） -- 裝置驅動
阿新 • • 發佈：2019-02-13
裝置驅動關注的結構體主要有兩個，struct spi_device描述spi從裝置，struct spi_driver是從裝置的裝置驅動。
struct spi_device {
struct device dev;
struct spi_master *master;
u32 max_speed_hz;
u8 chip_select;
u8 bits_per_word;
u16 mode;
#define SPI_CPHA 0x01 /* clock phase */ 初始化函式如下，程式碼解釋參見程式碼註釋。此程式碼中包含了設備註冊的程式碼，但是在dts普遍應用後，此種設備註冊的方式已經被裝置樹的方式代替了，此處的設備註冊的應用場景多出現在以模組方式編譯的驅動設計中。因此請不要被設備註冊產生混淆。
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_MAJOR，裝置名是"spi"，檔案操作ops是spidev_fops，註冊後/proc/devices下有相關裝置，但不會向udev傳送uevent，如需要/dev下裝置節，需要手動配置
status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);
if (status < 0)
return status;
//建立spidev class, /sys/class/spidev
spidev_class = class_create(THIS_MODULE, "spidev");
if (IS_ERR(spidev_class)) {
status = PTR_ERR(spidev_class);
goto error_class;
}
//裝置驅動spidev_spi_driver註冊
status = spi_register_driver(&spidev_spi_driver);
if (status < 0)
goto error_register;
//設備註冊，一般是作為module driver的時候用這種註冊方式,busnum, chipselect可作為MODULE_PARAM傳入；
//正常情況下，裝置的註冊會在控制器驅動spi_master註冊過程中，對dts進行解析後進行spi slave裝置spi_device的註冊
if (busnum != -1 && chipselect != -1) {
struct spi_board_info chip = {
.modalias = "spidev", //與device_driver進行match使用
.mode = spimode, //spi工作模式
.bus_num = busnum, //spi master busnum
.chip_select = chipselect,
.max_speed_hz = maxspeed,
};
struct spi_master *master;
master = spi_busnum_to_master(busnum); //根據busnum找到註冊的spi_master
if (!master) {
status = -ENODEV;
goto error_busnum;
}
//spi slave裝置spi_device註冊的實現，並建立master和slave之間的關係
/* We create a virtual device that will sit on the bus */
spi = spi_new_device(master, &chip);
if (!spi) {
status = -EBUSY;
goto error_mem;
}
dev_dbg(&spi->dev, "busnum=%d cs=%d bufsiz=%d maxspeed=%d",
busnum, chipselect, bufsiz, maxspeed);
}
return 0;
error_mem:
error_busnum:
spi_unregister_driver(&spidev_spi_driver);
error_register:
class_destroy(spidev_class);
error_class:
unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
return status;
}
module_init(spidev_init);
下面是裝置驅動的定義，當compatible與設備註冊的屬性一致時，spidev_probe會被呼叫。
static const struct of_device_id spidev_dt_ids[] = {
{ .compatible = "rohm,dh2228fv", },
{ .compatible = "qcom,spi-msm-codec-slave", },
{},
};
MODULE_DEVICE_TABLE(of, spidev_dt_ids);
static struct spi_driver spidev_spi_driver = {
.driver = {
.name = "spidev",
.owner = THIS_MODULE,
.of_match_table = of_match_ptr(spidev_dt_ids),
},
.probe = spidev_probe,
.remove = 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.
*/
};probe函式定義如下，
static int spidev_probe(struct spi_device *spi)
{
struct spidev_data *spidev;
int status;
unsigned long minor;
/* Allocate driver data */
spidev = kzalloc(sizeof(*spidev), GFP_KERNEL);
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);
if (minor < N_SPI_MINORS) {
struct device *dev;
spidev->devt = MKDEV(SPIDEV_MAJOR, minor);
//裝置建立，/sys/class/spidev下會有spidev%d.%d相應裝置，同時udev也會在/dev下建立相應的節點
dev = device_create(spidev_class, &spi->dev, spidev->devt,
spidev, "spidev%d.%d",
spi->master->bus_num, spi->chip_select);
status = PTR_ERR_OR_ZERO(dev);
} 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); //將spidev加入device_list連結串列
}
mutex_unlock(&device_list_lock);
if (status == 0)
spi_set_drvdata(spi, spidev); //spi->dev->drvdata=spidev
else
kfree(spidev);
return status;
}檔案操作函式定義如下，
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,
};下面以open和write函式為例，對裝置操作函式進行說明，
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) { //根據節點inode->i_rdev在device_list連結串列中找到spidev
if (spidev->devt == inode->i_rdev) {
status = 0;
break;
}
}
if (status) {
pr_debug("spidev: nothing for minor %d\n", iminor(inode));
goto err_find_dev;
}
if (!spidev->tx_buffer) {
spidev->tx_buffer = kmalloc(bufsiz, GFP_KERNEL); //申請tx buffer
if (!spidev->tx_buffer) {
dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
status = -ENOMEM;
goto err_find_dev;
}
}
if (!spidev->rx_buffer) {
spidev->rx_buffer = kmalloc(bufsiz, GFP_KERNEL); //申請rx buffer
if (!spidev->rx_buffer) {
dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
status = -ENOMEM;
goto err_alloc_rx_buf;
}
}
spidev->users++; //增加引用次數
filp->private_data = spidev; //將spidev傳給filp
nonseekable_open(inode, filp);
mutex_unlock(&device_list_lock);
return 0;
err_alloc_rx_buf:
kfree(spidev->tx_buffer);
spidev->tx_buffer = NULL;
err_find_dev:
mutex_unlock(&device_list_lock);
return status;
}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)
return -EMSGSIZE;
spidev = filp->private_data; //從傳入引數filp獲得spidev
mutex_lock(&spidev->buf_lock);
missing = copy_from_user(spidev->tx_buffer, buf, count); //將使用者態buf拷貝到spidev->tx_buf
if (missing == 0)
status = spidev_sync_write(spidev, count); //繼續呼叫spidev_sync_write實現
else
status = -EFAULT;
mutex_unlock(&spidev->buf_lock);
return status;
}write函式的具體實現如下，
static inline ssize_t
spidev_sync_write(struct spidev_data *spidev, size_t len)
{
struct spi_transfer t = {
.tx_buf = spidev->tx_buffer,
.len = len,
};
struct spi_message m;
spi_message_init(&m); //初始化spi_message
spi_message_add_tail(&t, &m); //將spi_transfer加入spi_message的佇列
return spidev_sync(spidev, &m); //繼續呼叫spidev_sync
}
static ssize_t
spidev_sync(struct spidev_data *spidev, struct spi_message *message)
{
DECLARE_COMPLETION_ONSTACK(done);
int status;
message->complete = spidev_complete;
message->context = &done; //spi_message的完成量賦值
spin_lock_irq(&spidev->spi_lock);
if (spidev->spi == NULL)
status = -ESHUTDOWN;
else
status = spi_async(spidev->spi, message); //呼叫spi_async非同步傳輸
spin_unlock_irq(&spidev->spi_lock);
if (status == 0) {
wait_for_completion(&done); //等待完成量
status = message->status;
if (status == 0)
status = message->actual_length;
}
return status;
}
int spi_async(struct spi_device *spi, struct spi_message *message)
{
struct spi_master *master = spi->master;
int ret;
unsigned long flags;
ret = __spi_validate(spi, message);
if (ret != 0)
return ret;
spin_lock_irqsave(&master->bus_lock_spinlock, flags);
if (master->bus_lock_flag)
ret = -EBUSY;
else
ret = __spi_async(spi, message); //繼續呼叫__spi_async
spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
return ret;
}
static int __spi_async(struct spi_device *spi, struct spi_message *message)
{
struct spi_master *master = spi->master; //獲取master
message->spi = spi; //spi_message傳送到的裝置
trace_spi_message_submit(message);
return master->transfer(spi, message); //呼叫master->transfer進行傳輸
}transfer函式的實現在控制器驅動章節中有詳細的描述，在此處不再進行重複。