u-boot阶段的GPIO控制

ThanksView 2024-04-20 10:42:57

RK3399为例-GPIO1_A0 在u-boot启动阶段的控制方法

//控制脚GPIO1_A0  32*1+8*0+0 = 32

一般u-boot对GPIO的控制有如下两种方法:

1,传统方式


//u-boot阶段使用GPIO时,必须先申请
gpio_request(GPIO_BANK1 | GPIO_A0 ,"HDMI-PWR"); //u-boot阶段,这里只能使用GPIO_BANK1 | GPIO_A0 不能直接使用32
gpio_direction_output(GPIO_BANK1 | GPIO_A0 , 1); //设置为高电平,开启HDMI通信


2,地址映射方式

typedef volatile unsigned int u32;
u32 cfg, value;
 
//step1.set output. 
cfg = *(u32 *)(基地址 + 控制寄存器偏移地址); 
value = cfg & ~(7 << 4); //控制寄存器设置
value = value | (1 << 4); 
*(u32 *)(基地址 + 控制寄存器偏移地址) =value;
 
//step2.write value
cfg = *(u32 *)(基地址 + 数据寄存器偏移地址);
value = cfg | (1 << 17); //要写入的数据
*(u32 *)(基地址 + 数据寄存器偏移地址) =value;


基于 GPIO子系统的 IO口控制

gpio 子系统 API 函数

1、gpio_request 函数

gpio_request 函数用于申请一个 GPIO 管脚,在使用一个 GPIO 之前一定要使用 gpio_request
进行申请,函数原型如下:

      int 
      gpio_request
      (
      unsigned gpio
      , 
      const 
      char 
      *label
      ) 

函数参数和返回值含义如下:


  • gpio:要申请的 gpio 标号,使用 of_get_named_gpio 函数从设备树获取指定 GPIO 属性信
    息,此函数会返回这个 GPIO 的标号。
  • label:给 gpio 设置个名字。
  • 返回值:0,申请成功;其他值,申请失败。

2、gpio_free 函数

如果不使用某个 GPIO 了,那么就可以调用 gpio_free 函数进行释放。函数原型如下:

      void 
      gpio_free
      (
      unsigned gpio
      ) 
  • 函数参数和返回值含义如下:
  • gpio:要释放的 gpio 标号。
  • 返回值:无。
3、gpio_direction_input 函数
此函数用于设置某个 GPIO 为输入,函数原型如下所示:
      int 
      gpio_direction_input
      (
      unsigned gpio
      ) 


函数参数和返回值含义如下:

gpio:要设置为输入的 GPIO 标号。

返回值:0,设置成功;负值,设置失败。
4、gpio_direction_output 函数
此函数用于设置某个 GPIO 为输出,并且设置默认输出值,函数原型如下:
      int 
      gpio_direction_output
      (
      unsigned gpio
      , 
      int value
      )

函数参数和返回值含义如下:

gpio:要设置为输出的 GPIO 标号。
value:GPIO 默认输出值。
返回值:0,设置成功;负值,设置失败。
5、gpio_get_value 函数
此函数用于获取某个 GPIO 的值(0 或 1),此函数是个宏,定义所示:
int __gpio_get_value(unsigned gpio)2
函数参数和返回值含义如下:
      
       #
      define 
      gpio_get_value 
      __gpio_get_value 
      int 
      __gpio_get_value
      (
      unsigned gpio
      ) 

gpio:要获取的 GPIO 标号。

返回值:非负值,得到的 GPIO 值;负值,获取失败。
6、gpio_set_value 函数
此函数用于设置某个 GPIO 的值,此函数是个宏,定义如下
      
       #
      define 
      gpio_set_value 
      __gpio_set_value
      void 
      __gpio_set_value
      (
      unsigned gpio
      , 
      int value
      )

函数参数和返回值含义如下:


gpio:要设置的 GPIO 标号。
value:要设置的值。
返回值:无
关于 gpio 子系统常用的 API 函数就讲这些,这些是我们用的最多的。
GPIO子系统示例 读取按键
/*
 * @Copyright: 
 * @FileNames: 
 * @Description: 申请全局内存4096 并使用该内存进行 用户和内核之间的数据交换
 * @Author: yangyue19@hikvision.com.cn
 * @Date: 2022-07-29 09:03:02
 * @Version: V1.0
 * @LastEditTime: 2022-08-05 16:51:03
 */
#include <linux/module.h>//MOUDLE_XXX moudle_xxx
#include <linux/fs.h>    //file_operations register_chrdev_region alloc_chrdev_region
#include <linux/init.h>  //__init __exit
#include <linux/cdev.h>  //cdev
#include <linux/uaccess.h>//copy_to_user copy_from_user 
#include <linux/device.h> // device class 

#include <linux/gpio.h>
#define KEY_DEBUG 1

#define KEY_CLASS_NAME "key" //创建的类名称
#define KEY_NODE_NAME  "key_0" //创建的节点名称

#define KEY_MAJOR 250

typedef struct {
    //设备驱动变量
    struct cdev cdev;
    //设备号变量
    dev_t devid;
    int major;
    int minor;      
    //设备节点相关变量
    struct class *class; 
    struct device *device;
    //按键使用的GPIO编号
    int key_index;
    //用户变量
    //上一次读取的按键数值
    int last_value;
    int value;
}rtl_key_t;

rtl_key_t key;

/**
 * @function: key_open
 * @description: 打开设备 并将内存清零
 * @input: 
 * @output: 
 * @return {*}
 * @param {inode} *inode
 * @param {file} *flip
 */
static int key_open(struct inode *inode ,struct file *flip)
{
    flip->private_data=(void *)(&key);
    return 0;
}
/**
 * @function: key_release
 * @description: 释放设备节点
 * @input: 
 * @output: 
 * @return {*}
 * @param {inode} *inode
 * @param {file} *flip
 */
static int key_release(struct inode *inode ,struct file *flip)
{
    return 0;
}

/**
 * @function: key_read
 * @description: 拷贝数据到用户区
 * @input: 
 * @output: 
 * @return {*}
 * @param {file*} flip  文件结构体
 * @param {char __user} *buf 从用户区拷贝出来的数据
 * @param {size_t} size      传入数据大小
 * @param {loff_t} *ppos     当前数据位置
 */
static ssize_t key_read(struct file* flip, char __user *buf,size_t size ,loff_t *ppos)
{
    int ret=0;
    rtl_key_t* dev=(rtl_key_t*) flip->private_data;

    ret= gpio_get_value(dev->key_index);
    copy_to_user(buf,&ret,sizeof(ret));
    return 4;
}

/**
 * @function: key_write
 * @description: 
 * @input: 
 * @output: 
 * @return {*}
 * @param {file*} flip
 * @param {char __user} *buf
 * @param {size_t} size
 * @param {loff_t} *ppos
 */
static ssize_t key_write(struct file* flip, const char __user *buf,size_t size ,loff_t *ppos)
{
    int ret=0;
    
    rtl_key_t* dev=(rtl_key_t*) flip->private_data;

    if(ret<0)ret=-EFAULT;
    else{
    }
    return ret;
}

static const struct file_operations key_fops={
    .owner=THIS_MODULE,
    .open=key_open,
    .release=key_release,
    .read=key_read,
    .write=key_write,
};

/**
 * @function: static void key_setup_cdev(int minor_index)
 * @description: 根据一个从设备号生成cdev
 * @input: 
 * @output: 
 * @return {*}
 */
static void key_setup_cdev(int minor_index)
{
    int ret;
    //得到设备号
    int devno=MKDEV(key.major,minor_index);
    cdev_init(&key.cdev,&key_fops);
    key.cdev.owner=THIS_MODULE;
    ret=cdev_add(&key.cdev,devno,1);
    if(ret)printk(KERN_INFO"CDEV ADD ERROR:%d\n",minor_index);
}

/**
 * @function: key_init
 * @description: 申请设备号 并且注册cdev 
 * @input: void
 * @output: 
 * @return {*}
 */
static int __init key_init(void)
{
    int ret;
    //如果定义了静态主设备号 就采用静态申请的方式
    key.major=KEY_MAJOR;
    printk(KERN_INFO "KEY INIT\r\n");
    key.key_index=58;
    gpio_request(key.key_index, "key");
    ret = gpio_direction_input(key.key_index);
    if(ret<0)printk(KERN_INFO  "CAN NOT SET PIN\n");

    //得到需要注册的设备号
    key.devid=MKDEV(key.major,key.minor);
    if(key.major!=0){//从devno 静态申请 一个设备号
        ret=register_chrdev_region(key.devid,1,"key");
    }else{//从devno 动态申请一个设备号
        ret=alloc_chrdev_region(&key.devid,0,1,"key");
        key.major=MAJOR(key.devid);
        key.minor=MINOR(key.devid);
    }
    if(KEY_DEBUG){
        printk(KERN_INFO  "major:%d\n",key.major);
        printk(KERN_INFO  "minor:%d\n",key.minor);   
    }
    key_setup_cdev(key.minor);
    //创建设备 创建类
    key.class = class_create(THIS_MODULE, KEY_CLASS_NAME);
    key.device = device_create(key.class, NULL, key.devid, NULL, KEY_NODE_NAME);

    return 0;
}
module_init(key_init);

static void __exit key_exit(void)
{
    cdev_del(&key.cdev);
    unregister_chrdev_region(key.devid,1);

    gpio_free(key.key_index);
    //删除设备 删除类
    device_destroy(key.class, key.devid);
    class_destroy(key.class);
}
module_exit(key_exit);
 
MODULE_AUTHOR("YURI");
MODULE_LICENSE("GPL");

/*
 * @Copyright: 
 * @FileNames: 
 * @Description: 
 * @Author: yangyue19@hikvision.com.cn
 * @Date: 2022-07-29 13:44:24
 * @Version: V1.0
 * @LastEditTime: 2022-08-05 17:06:38
 */
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ioctl.h>

#define DEVICE_NAME "/dev/key"

int main()
{
    int i=0,ret=0,key=0;
    int fd=open(DEVICE_NAME,O_RDWR);
    if(ret<0)perror("open error");

    while (1)
    {
        ret=read(fd,(void*)&key,4);
        printf("KEY VALUE:%d\n",key);
        sleep(1);
    }
    
    close(fd);
    return 0;
}

注意
因为权限问题,所以没有办法手动添加设备节点,也没有mdev,udev进行设备节点的管理,
所以需要手动添加设备节点。所以需要改一个脚本
rootfs\tools\mkimg
添加

echo “/dev/key c 666 root root 250 0” >> squashfs-pf-list.txt

打印问题,默认打印等级很低
可以使用echo 8 > /proc/sys/kernel/printk调整打印等级


粤ICP备18089419号