spi子系统实现数码管控制

任务目标

应用层程序控制数码管显示数字

大致思路

1、定义初始化spi对象并注册
2、匹配设备树节点
3、匹配成功后，在probe函数中注册字符设备驱动
4、通过字符设备驱动对内核写入需要变换的数码管数组
5、在内核层实现write函数获取到应用层内容时对数码管进行控制
6、应用层循环发送0-9数据 依次给4个数码管，实现类似流水灯控制

代码实现

驱动代码

#include <linux/init.h>
#include<linux/spi/spi.h>
 //#include <linux/fs.h>
 //#include <linux/io.h>
 //#include <linux/cdev.h>
 //#include <linux/uaccess.h>
 #include <linux/module.h>

struct cdev *cdev;
struct class *cls;
struct device *dev;   
char  kbuf[]={0x1,0x3f};
struct spi_device *spi1=NULL;

int minor=0;//次设备号从0开始
#if 1 
unsigned int major = 0;//动态申请
#else                                     
unsigned int major = 500;//静态指定设备号
#endif
//对应的是open()
int mycdev_open(struct inode *inode, struct file *file)
{
      printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
      return 0;
}

ssize_t mycdev_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff)
{
    
    //size参数是用户期待读到的字节长度
    int ret;
    if(size>sizeof(kbuf))
    size=sizeof(kbuf);
    ret=copy_to_user(ubuf,kbuf,size);
    if(ret)
    {
        printk("数据从内核向用户拷贝失败\n");
        return -EIO;
    }
     
       return size;
}


ssize_t mycdev_write(struct file *file, const char __user *ubuf, size_t size, loff_t *loff)
{
    int ret;
    if(size>sizeof(kbuf))
    size=sizeof(kbuf);
    ret=copy_from_user(kbuf,ubuf,size);
    spi_write(spi1,kbuf,sizeof(kbuf));

    if(ret)
    {
        printk("数据从内核向用户拷贝失败\n");
        return -EIO;
    }

       return size;
}
int mycdev_close(struct inode *inode, struct file *file)
{
      printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
       return 0;
}



struct file_operations fops=
{
    .open=mycdev_open,
    .read=mycdev_read,
    .write=mycdev_write,
    .release=mycdev_close,
};

int m74hc595_probe(struct spi_device *spi)
{
	    int ret,i;
    dev_t devno;
       printk("%s:%d\n",__FILE__,__LINE__);
    spi_write(spi,kbuf,sizeof(kbuf));
	
	spi1=spi;
    //分配对象
    cdev=cdev_alloc();
    //注册对象

    if(cdev==NULL)
    {
        printk("cdev alloc memory err\n");

        ret = -ENOMEM;
        goto ERR1;
    }
    printk("对象分配成功\n");
    //对象的初始化
    cdev_init(cdev,&fops);
    //设备号的申请

    if(major==0)//动态申请
    {
        ret=alloc_chrdev_region(&devno,minor,1,"keyirq");

        if(ret)
        {
            printk("动态申请设备号失败\n");
            goto ERR2;
        }
        major = MAJOR(devno);
        minor = MINOR(devno);
        printk("动态申请设备号成功\n");
    }
    else
    {
        ret=register_chrdev_region(MKDEV(major,minor),1,"keyirq");
        if(ret)
        {
            printk("静态申请设备号失败\n");
            goto ERR2;
        }
        printk("静态申请设备号成功\n");
     }
     //注册字符设备驱动
     ret=cdev_add(cdev,MKDEV(major,minor),1);
     if(ret)
     {
         printk("字符设备驱动注册失败\n");
         goto ERR3;
     }
     printk("注册字符设备驱动成功\n");

     //自动创建设备节点
     cls = class_create(THIS_MODULE,"keyirq1");
     if(IS_ERR(cls))
     {
         printk("创建逻辑节点目录失败\n");
         ret=PTR_ERR(cls);
         goto ERR4;
     }
     printk("创建逻辑节点目录成功\n");
     //向上提交节点信息
     dev = device_create(cls,NULL,MKDEV(major,0),NULL,"keyirq");
     if(IS_ERR(dev))
     {
         printk("创建逻辑节点失败\n");
         ret = PTR_ERR(dev);
         goto ERR5;
     }
printk("创建逻辑节点成功\n");
return 0;
ERR5:
for(--i;i>=0;i--)
{
    device_destroy(cls,MKDEV(major,i));
}
class_destroy(cls);
ERR4:
cdev_del(cdev);
ERR3:
unregister_chrdev_region(MKDEV(major,minor),0);
ERR2:
kfree(cdev);
ERR1:
return ret;

    return 0;
}
int m74hc595_remove(struct spi_device *spi)
{
     printk("%s:%d\n",__FILE__,__LINE__);
	 //1.销毁设备节点
         device_destroy(cls,MKDEV(major,0));
     class_destroy(cls);
    //2.注销字符设备驱动
    cdev_del(cdev);
    //3.释放设备号
    unregister_chrdev_region(MKDEV(major,minor),0);
    //4.释放动态申请的空间
    kfree(cdev);

     return 0;
}

//设备树匹配表
struct of_device_id of_table[]={
    {.compatible="hqyj,m74hc595"},
    {},
};
MODULE_DEVICE_TABLE(of,of_table);
//定义SPI对象并且初始化
struct spi_driver m74hc595 ={ 
    .probe=m74hc595_probe,
    .remove=m74hc595_remove,
    .driver={
        .name="m74hc595",
        .of_match_table=of_table,
    },
};





module_spi_driver(m74hc595); 
// module_init(mycdev_init); 
//module_exit(mycdev_exit); 
MODULE_LICENSE("GPL");
                             

测试代码

#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
#include <sys/ioctl.h>
//#include"myirq.h"
//#include<>
int main(int argc, char const *argv[])
{
    int fd=open("/dev/keyirq",O_RDWR);
    char ubuf[]={0x1,0x3f};
    if(fd<0)
    {

        printf("打开设备文件失败\n");
        exit(-1);
    }
    printf("设备文件打开成功\n");
    //在终端输入
    while(1)
    {
		if(ubuf[0]==0x1)
		{
			ubuf[0]=0x2;
		}
		else if(ubuf[0]==0x2)
		{
			ubuf[0]=0x4;
		}
		else if(ubuf[0]==0x4)
		{
			ubuf[0]=0x8;
		}
		else if(ubuf[0]==0x8)
		{
			ubuf[0]=0x1;
		}
		switch(ubuf[1])
		{
		case 0x3f:
			ubuf[1]=0x06;
			break;
		case 0x06:
			ubuf[1]=0x5b;
			break;
		case 0x5b:
			ubuf[1]=0x4f;
			break;
		case 0x4f:
			ubuf[1]=0x66;
			break;
		case 0x66:
			ubuf[1]=0x6d;
			break;
		case 0x6d:
			ubuf[1]=0x7d;
			break;
		case 0x7d:
			ubuf[1]=0x07;
			break;
		case 0x07:
			ubuf[1]=0x7f;
			break;
		case 0x7f:
			ubuf[1]=0x6f;
			break;
		case 0x6f:
			ubuf[1]=0x3f;
			break;

		}
        write(fd,&ubuf,sizeof(ubuf));
		for(int i=0;i<10000000;i++)
		{}	
	//	sleep(1);
    
    }
    close(fd);
    return 0;
}