PetaLinux驱动学习——Pinctrl和GPIO子系统

#include <dt-bindings/gpio/gpio.h>
#include <dt-bindings/pinctrl/pinctrl-zynq.h>

/include/ "system-conf.dtsi"
/ {
    led_gpio {
        pinctrl-names = "default";
        pinctrl-0 = <&pinctrl_led_default>;
        
        led-gpios = <&gpio0 0 GPIO_ACTIVE_HIGH>, /* led0 */
                    <&gpio0 1 GPIO_ACTIVE_HIGH>, /* led1 */
                    <&gpio0 2 GPIO_ACTIVE_HIGH>, /* led2 */
                    <&gpio0 3 GPIO_ACTIVE_HIGH>; /* led3 */
    };
}; 

&pinctrl0 {
    pinctrl_led_default: led-default {
        mux {
            function = "gpio0";
            groups = "gpio0_0_grp", "gpio0_1_grp", 
                     "gpio0_2_grp", "gpio0_3_grp";
        };
       
        conf {
            groups = "gpio0_0_grp", "gpio0_1_grp", 
                     "gpio0_2_grp", "gpio0_3_grp";   
            pins = "MIO0", "MIO1", "MIO2", "MIO3";
            slew-rate = <0>;
            power-source = <IO_STANDARD_LVCMOS33>;
            bias-disable;
        };
    };
};

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/cdev.h>
#include <linux/device.h>

#define xxx_COUNT 1
#define xxx_NAME "xxx"
 
static struct xxx_device{
    dev_t               devid;
    struct cdev         cdev;
    struct class       *class;
    struct device      *device;
} xxx;

// 文件操作函数
static int xxx_open(struct inode *inode, struct file *filp) {  
    return 0;
}

static int xxx_release(struct inode *inode, struct file *filp) {  
    return 0;
}

static ssize_t xxx_write(struct file *filp, const char *buf, 
                        size_t count, loff_t *ppos) {  
    int retval;
    unsigned char databuf[x];

    retval = copy_from_user(databuf, buf, count);
    if(retval < 0) {
        printk("copy_from_user error\r\n");
        return -EFAULT;
    }

    // 执行操作
    // ...
    return 0;
} 

static ssize_t xxx_read(struct file *filp, char __user *buf, 
                       size_t count, loff_t *ppos) { 
    int retval = 0; 
    unsigned char databuf[x];

    // 执行操作
    // ...

    /* 向用户空间发送数据 */ 
    retval = copy_to_user(buf, databuf, count);
    if(retval < 0) {
        printk("copy_to_user error\r\n");
        return -EFAULT;
    }

    return 0; 
} 

// 文件操作结构体
static const struct file_operations xxx_fops = {
    .owner   = THIS_MODULE,
    .open    = xxx_open,
    .release = xxx_release,
    .write   = xxx_write,
    .read    = xxx_read
    // 其余文件操作...
};

// 模块初始化函数
static int __init xxx_init(void) {
    int retval; 

    // 1. 申请设备号
    retval = alloc_chrdev_region(&xxx.devid, 0, xxx_COUNT, xxx_NAME); 
    if (retval < 0) {
        printk("fail to register devid\r\n");
        goto fail_devid;
    }

    // 2. 添加字符设备
    xxx.cdev.owner = THIS_MODULE;
    cdev_init(&xxx.cdev, &xxx_fops);
    retval = cdev_add(&xxx.cdev, xxx.devid, xxx_COUNT);
    if (retval < 0) {
        printk("fail to add cdev\r\n");
        goto fail_cdev;
    }

    // 3. 创建设备类
    xxx.class = class_create(THIS_MODULE, xxx_NAME);
    if(IS_ERR(xxx.class)){
        printk("fail to create device class\r\n");
        retval = PTR_ERR(xxx.class);
        goto fail_class;
    }

    // 4. 自动创建设备文件：/dev/xxx
    xxx.device = device_create(xxx.class, NULL, xxx.devid, NULL, xxx_NAME);
    if(IS_ERR(xxx.device)){
        printk("fail to create device\r\n");
        retval = PTR_ERR(xxx.device);
        goto fail_device;
    } 
    
    // 5. 其余特定需求的初始化
    // ...
    
    return 0;

    // 错误处理
fail_device:
    class_destroy(xxx.class);
fail_class:
    cdev_del(&xxx.cdev);
fail_cdev:
    unregister_chrdev_region(xxx.devid, xxx_COUNT);
fail_devid:
    return retval;
}

// 模块退出函数
static void __exit xxx_exit(void) {  
    // 销毁设备文件
    device_destroy(xxx.class, xxx.devid);
    // 销毁设备类
    class_destroy(xxx.class);
    // 删除字符设备
    cdev_del(&xxx.cdev);
    // 释放设备号
    unregister_chrdev_region(xxx.devid, xxx_COUNT);
}

module_init(xxx_init);
module_exit(xxx_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("xxx");

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>               // of_find_node_by_path所需
#include <linux/gpio/consumer.h>    // GPIO API所需

#define LED_COUNT 1
#define LED_NAME "led"

// LED设备结构体
static struct led_device{
    dev_t                devid;
    struct cdev          cdev;
    struct class        *class;
    struct device       *device;
    struct gpio_descs   *led_gpios;  // GPIO描述符数组
} led;

// 文件操作函数
static int led_open(struct inode *inode, struct file *filp) {  
    return 0;
}

static int led_release(struct inode *inode, struct file *filp) {  
    return 0;
}

static ssize_t led_write(struct file *filp, const char *buf, 
                        size_t count, loff_t *ppos) {  
    int retval;
    unsigned char databuf[1];
    unsigned long led_bitmap;

    // 从用户空间复制数据
    retval = copy_from_user(databuf, buf, count);
    if(retval < 0) {
        printk("copy_from_user error\r\n");
        return -EFAULT;
    }

    // 根据databuf的值决定打开哪个灯（位图方式）
    led_bitmap = databuf[0] == 0 ? 1 :  // LED0: 0001
                 databuf[0] == 1 ? 2 :  // LED1: 0010
                 databuf[0] == 2 ? 4 :  // LED2: 0100
                 databuf[0] == 3 ? 8 :  // LED3: 1000
                 0;                     // 其他值关闭所有LED
    
    // 设置GPIO数组的值
    gpiod_set_array_value(led.led_gpios->ndescs, 
                         led.led_gpios->desc, 
                         led.led_gpios->info, 
                         &led_bitmap);

    return 0;
}

// 文件操作结构体
static const struct file_operations led_fops = {
    .owner   = THIS_MODULE,
    .open    = led_open,
    .release = led_release,
    .write   = led_write,
};

// 模块初始化函数
static int __init led_init(void) {
    int retval;

    // 1. 注册设备号
    retval = alloc_chrdev_region(&led.devid, 0, LED_COUNT, LED_NAME);
    if (retval < 0) {
        printk("fail to register devid\r\n");
        goto fail_devid;
    }

    // 2. 添加字符设备
    led.cdev.owner = THIS_MODULE;
    cdev_init(&led.cdev, &led_fops);
    retval = cdev_add(&led.cdev, led.devid, LED_COUNT);
    if (retval < 0) {
        printk("fail to add cdev\r\n");
        goto fail_cdev;
    }

    // 3. 创建设备类
    led.class = class_create(THIS_MODULE, LED_NAME);
    if(IS_ERR(led.class)) {
        printk("fail to create device class\r\n");
        retval = PTR_ERR(led.class);
        goto fail_class;
    }

    // 4. 自动创建设备文件：/dev/led
    led.device = device_create(led.class, NULL, led.devid, NULL, LED_NAME);
    if(IS_ERR(led.device)) {
        printk("fail to create device\r\n");
        retval = PTR_ERR(led.device);
        goto fail_device;
    }

    // 5. 指定设备树节点（防止多个led-gpios情况）
    led.device->of_node = of_find_node_by_path("/led_gpio");
    if(led.device->of_node == NULL) {
        printk("fail to find node\r\n");
        retval = -EINVAL;
        goto fail_findnd;
    }
    
    // 6. 获取GPIO描述符数组
    led.led_gpios = gpiod_get_array(led.device, "led", GPIOD_OUT_LOW);
    if(IS_ERR(led.led_gpios)) {
        printk("fail to get gpio array\r\n");
        retval = PTR_ERR(led.led_gpios);
        goto fail_gpio;
    }

    printk("LED driver loaded successfully\r\n");
    return 0;

    // 错误处理
    fail_gpio:
    fail_findnd:
        device_destroy(led.class, led.devid);
    fail_device:
        class_destroy(led.class);
    fail_class:
        cdev_del(&led.cdev);
    fail_cdev:
        unregister_chrdev_region(led.devid, LED_COUNT);
    fail_devid:
        return retval;
}

// 模块退出函数
static void __exit led_exit(void) {   
    // 释放GPIO描述符
    gpiod_put_array(led.led_gpios);
    // 销毁设备文件
    device_destroy(led.class, led.devid);
    // 销毁设备类
    class_destroy(led.class);
    // 删除字符设备
    cdev_del(&led.cdev);
    // 释放设备号
    unregister_chrdev_region(led.devid, LED_COUNT);
    
    printk("LED driver unloaded\r\n");
}

module_init(led_init);
module_exit(led_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("raiset");
MODULE_DESCRIPTION("LED GPIO Driver for PetaLinux");

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>

#define FILE_NAME "/dev/led"

int main(int argc, char **argv) {
    int fd;
    int ret;
    unsigned char databuf[1];

    // 参数数量检查
    if(argc != 2) {
        printf("Usage: %s <led_number>\r\n", argv[0]);
        printf("  led_number: 0-3 (LED0-LED3)\r\n");
        return -1;
    }

    // 打开设备文件
    fd = open(FILE_NAME, O_RDWR);
    if(fd < 0) {
        printf("Error: cannot open file %s\r\n", FILE_NAME);
        printf("Please check if the driver is loaded: sudo insmod led.ko\r\n");
        return -1;
    }

    // 将字符串转换为整数
    databuf[0] = (unsigned char)atoi(argv[1]);
    
    // 参数范围检查
    if(databuf[0] > 3) {
        printf("Warning: LED number should be 0-3, got %d\r\n", databuf[0]);
    }

    // 写入数据到驱动
    ret = write(fd, databuf, 1);
    if(ret < 0) {
        printf("Error: cannot write to file %s\r\n", FILE_NAME);
        close(fd);
        return -1;
    }

    printf("LED%d controlled successfully\r\n", databuf[0]);

    // 关闭设备文件
    ret = close(fd);
    if(ret < 0) {
        printf("Error: cannot close file %s\r\n", FILE_NAME);
        return -1;
    }

    return 0;
}