Linux驱动开发之平台总线

#include <linux/init.h>
#include <linux/module.h>
#include <linux/device.h>
#include <string.h>

int mybus_match(struct device *dev, struct device_driver *drv)
{
    //如果匹配成功，一定要返回1，失败返回0。
    if(!strncmp(drv->name, dev->kobj.name/*不能用init_name，它会被kobject清空。*/, strlen(drv->name)))
    {
        //名称匹配成功。
        printk("match ok.\n");
        return 1;
    }
    else
    {
        printk("match failed.\n");
        return 0;
    }
}

//实例化一个bus对象
struct bus_type mybus = {
    .name = "mybus",
    .match = mybus_match,
};

EXPORT_SYMBOL(mybus); //只有这样其它ko才能访问到这个结构体对象。dev.c中的extern仅仅是为了通过编译才加的。ko真正运行起来以后还得靠这个EXPORT_SYMBOL()的开放才能正常使用到。

static int __init mybus_init()
{
    //构建一个总线 /sys/bus/mybus
    
    int ret = bus_register(&mybus);//这段代码运行以后即可在 /sys/bus 下看到‘mybus‘目录被创建。
    
    return 0;
}

static void __exit mybus_exit()
{
    bus_unregister(&mybus);
}

module_init(mybus_init);
module_exit(mybus_exit);
MODULE_LICENSE("GPL");

#include <linux/init.h>
#include <linux/module.h>
#include <linux/device.h>

extern struct bus_type mybus; //mybus在bus.c文件中

//设置一个自定义数据，描述设备的特性。用于传给 device 结构体的 platform_data。
struct mydev_desc{
    char *name;
    int irq;
    unsigned long addr;
};

struct mydev_desc devinfo = {
    .name = "testdev",
    .irq = 999,
    .addr = 0x30000000,
};

void mydev_release(struct device *dev)
{
    printk("mydev_release()\n");
}

//实例化一个bus对象
struct device mydev = {
    .init_name = "fsdev_drv", //要与drv.c中的name一致。
    .bus = &mybus,
    .release = mydev_release,
    .platform_data = &devinfo,
};

static int __init mydev_init()
{
    //将device注册到总线中 /sys/bus/mybus/devices
    
    int ret = device_register(&mydev); //这段代码运行成功后即可在 /sys/bus/mybus/devices 目录下创建一个 mydev 目录。
    
    return 0;
}

static void __exit mydev_exit()
{
    device_unregister(&mydev);
}

module_init(mydev_init);
module_exit(mydev_exit);
MODULE_LICENSE("GPL");

/*
    这个是驱动代码。
*/
#include <linux/init.h>
#include <linux/module.h>
#include <linux/device.h>

extern struct bus_type mybus;

struct mydev_desc *pdesc; //这个结构体在 dev.c 中定义，不能在这里直接使用。

int mydrv_probe(struct device *dev)
{
    printk("mydrv_probe()\n");
    
    pdesc = (struct mydev_desc *)dev->platform_data;
    //将信息打印出来验证数据是否与在dev.c中设定时的一致。
    printk("name:%s\nirq:%d\n", pdesc->name, pdesc->irq);
    
    return 0;
}

int mydrv_remove(struct device *dev)
{
    return 0;
}

struct device_driver mydrv = {
    .name = "fsdev_drv", //要与dev.c中的init_name一致。
    .bus = &mybus,
    .probe = mydrv_probe,
    .remove = mydrv_remove,
};

static int __init mydrv_init()
{
    //将driver注册到总线中 /sys/bus/mybus/drivers
    
    int ret = driver_register(&mydrv); //这段代码运行成功后即可在 /sys/bus/mybus/drivers 目录下可以看到有一个 mydrv 目录生成。
    
    return 0;
}

static void __exit mydrv_exit()
{
    driver_unregister(&mydrv);
}

module_init(mydrv_init);
module_exit(mydrv_exit);
MODULE_LICENSE("GPL");

#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <plat/irqs.h>

#define GPX3_CON 0x1140000
//GPX3寄存器中有6个，每个的地址占4个字节，因此值是24。
#define GPX3_SIZE 24

//一个设备可能有多个资源，因此给个数组。
struct resource led_res[] = {
    [0] = {
        .start = GPX3_CON,
        .end = GPX3_CON + GPX3_SIZE - 1, //地址计算容易错，要搞清楚了。
        .flags = IORESOURCE_MEM,
    },//第0个数组做初始化。
    
    [1] = {
        .start = GPX3_CON,
        .end = GPX3_CON + GPX3_SIZE - 1,
        .flags = IORESOURCE_MEM,
    },
    
    [2] = {
        .start = 24,
        .end = 24,//start与end表示中断号。因为中断号是不连续的，因此开始与结束是一致的。
        .flags = IORESOURCE_IRQ,
    },
};

struct platform_device pdev = {
    .name = "led_dev_test",
    .id = -1,
    .num_resources = ,
    .resource = ,
};

static int __init plt_led_dev_init()
{
    //注册
    int ret = platform_device_register(&led_pdev);
    
    return 0;
}

static void __exit plt_led_dev_exit()
{
    platform_device_unregister(&led_pdev);
}

module_init(plt_led_dev_init);
module_exit(plt_led_dev_exit);
MODULE_LICENSE("GPL");

#include <linux/init.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/ioport.h>

#include <asm/uaccess.h>
#include <asm/io.h>

struct led_dev{
    int dev_major;
    struct class *cls;
    struct device *dev;
    struct resource *res; //获取到的硬件资源描述信息对象。
    void *reg_base; //保存物理地址映射之后的虚拟地址。
};

struct led_dev *sled;

ssize_t led_pdrv_write(struct file *fp, const char __user *buf, size_t count, loff_t *fpos)
{
    int val;
    int ret = copy_from_user(&val, buf, count);
    if(ret == 0)
    {
        if(val)
        {
            //将亮LED灯的指令写到相应的虚拟地址上去。
        }
        else
        {
            //将灭LED灯的指令写到相应的虚拟地址上去。
        }
    }
    
    return count;
}

int led_pdrv_open(struct inode *inode, struct file *fp)
{
    return 0;
}

int led_pdrv_close(struct inode *inode, struct file *fp)
{
    return 0;
}

const struct file_operations fops = {
    .open = led_pdrv_open,
    .release = led_pdrv_close,
    .write = led_pdrv_write,
};

int led_pdrv_probe(struct platform_device *pdev)
{
    printk("%s()\n", __FUNCTION__);
    
    sled = kzalloc(sizeof(struct led_dev), GFP_KERNEL);
    //1、注册设备号
    sled->dev_major = register_chrdev(0, "sled_drv", &fops);
    
    //2、创建设备节点
    sled->cls = class_create(THIS_MODULE, "led_new_cls");
    sled->dev = device_create(sled->cls, NULL, MKDEV(sled->dev_major, 0), NULL, "sled0");
    
    //3、初始化硬件
    sled->res = platform_get_resource(pdev, IORESOURCE_MEM, 0);//直接调用系统函数来获取资源。取plt_led_dev中的led_res[]数组的第0个元素。
    struct resource *res1 = platform_get_resource(pdev, IORESOURCE_MEM, 1);//取plt_led_dev中的led_res[]数组的第1个元素。
    struct resource *res2 = platform_get_resource(pdev, IORESOURCE_IRQ, 0/*注意这个值，它表示同种资源的第n个。*/);//取plt_led_dev中的led_res[]数组的第2个元素。
    int iiirq = platform_get_irq(pdev, 0);//等同于上面那个函数调用。
    printk("演示，irq in resource:%d,,iiirq:%d\n", res2->start, iiirq);//两个数是相等的。
    
    ioremap(sled->res->start, sled->res->end = sled->res->start + 1);//为什么要+1，假设地址位为 0 ~ 7，则7-0=7，但实际上地址长度是8。
    sled->reg_base = ioremap(sled->res->start, resource_size(sled->res));//与上一行函数调用是等价的。
    //接下来可以配置相应寄存器了，这个操作就与相应芯片关联了。
    writel((readl(sled->reg_base) & ~(0xff<<16)) | (0x11<<16), sled->reg_base);
    
    //4、实现各种IO接口
    
    
    return 0;
}

int led_pdrv_remove(struct platform_device *pdev)
{
    printk("%s()\n", __FUNCTION__);
    
    iounmap(sled->reg_base);
    device_destroy(sled->cls, MKDEV(sled->dev_major, 0));
    class_destroy(sled->cls);
    unregister_chrdev(sled->dev_major, "sled_drv");
    kfree(sled);
    
    return 0;
}

const struct platform_device_id led_id_table[] = {
    {"led_dev_test", 0xfff}, //名称一致，表示这个驱动可以与 plt_led_dev.c 匹配上。
    {"led_dev_test2", 0xeee}, //可以匹配其它设备，名叫 led_dev_test2 的设备。
};

struct platform_driver led_pdrv = {
    
    .probe = led_pdrv_probe,
    .remove = led_pdrv_remove,
    .driver = {
        .name = "samsung_led_drv", //这个就是父类 device_driver 中的名字。若定义了 id_table，那这个名称就不用于做匹配，否则就是用来作匹配，必须与 plt_led_dev.c 中的 platform_device 中的名称一致。这里指定的名称还会在 /sys/bus/platform/drivers 目录下创建一个子目录。
    },
    .id_table = led_id_table,
};

static int __init plt_led_drv_init()
{
    int ret = platform_driver_register(&led_pdrv);
    
    return 0;
}

static void __exit plt_led_drv_exit()
{
    platform_driver_unregister(&led_pdrv);
}

module_init(plt_led_drv_init);
module_exit(plt_led_drv_exit);
MODULE_LICENSE("GPL");