linux gpio模拟I2c驱动(基于海思平台)

最新推荐文章于 2022-12-13 13:57:59 发布
最新推荐文章于 2022-12-13 13:57:59 发布
阅读量1.2k 收藏 12
点赞数 2
分类专栏： linux 文章标签： GPIO I2C 驱动程序 模拟通信 ioctl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gpio_01/article/details/115299071
版权

多字节操作bug见评论1

驱动程序：gpio_i2c.h


#ifndef _GPIO_I2C_H_
#define _GPIO_I2C_H_


typedef struct {
	unsigned char  dev_addr;
	unsigned short reg_addr;
	unsigned char  addr_byte_num;
	unsigned int  data;
	unsigned char  data_byte_num;
}GPIOI2C_DATA_S;
 /* 定义幻数 */
#define MEMDEV_IOC_MAGIC  'k'
 
/* 定义命令 */
#define GPIO_I2C_READ   _IOWR(MEMDEV_IOC_MAGIC, 0x01,GPIOI2C_DATA_S)
#define GPIO_I2C_SELCHN   _IOWR(MEMDEV_IOC_MAGIC, 0x05,GPIOI2C_DATA_S)
#define GPIO_I2C_WRITE   _IOWR(MEMDEV_IOC_MAGIC, 0x03,GPIOI2C_DATA_S)
#define GPIO_I2C_WRITE2   _IOWR(MEMDEV_IOC_MAGIC, 0x07,GPIOI2C_DATA_S)
#define GPIO_I2C_WRITE4   _IOWR(MEMDEV_IOC_MAGIC, 0x09,GPIOI2C_DATA_S)
typedef unsigned char		byte;

#define high_scl i2c_set(SCL)
#define low_scl i2c_clr(SCL)
#define high_sda i2c_set(SDA)
#define low_sda i2c_clr(SDA)



unsigned char gpio_i2c_read(unsigned char devaddress, unsigned char address);
void gpio_i2c_write(unsigned char devaddress, unsigned int address, unsigned char value);





#endif

gpio_i2c.c

#include <linux/module.h>
#include <linux/errno.h>
#include <linux/miscdevice.h>
#include <linux/fcntl.h>

#include <linux/init.h>
#include <linux/delay.h>
#include <linux/proc_fs.h>
#include <linux/workqueue.h>

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

#include "gpio_i2c.h"
#define demo_delay time_delay_us(2)
#ifdef HI_FPGA

#define GPIO_15_BASE 0x12240000
#define SCL_SHIFT_NUM 2
#define SDA_SHIFT_NUM 3
#define SCL (0x1 << SCL_SHIFT_NUM)                                                                                   /* GPIO7 0_7 */
#define SDA (0x1 << SDA_SHIFT_NUM)                                                                                   /* GPIO7 0_6 */
#define GPIO_I2C_SCL_REG IO_ADDRESS(GPIO_15_BASE + (0x1 << (SCL_SHIFT_NUM + 2)))                                     /* 0x200 */
#define GPIO_I2C_SDA_REG IO_ADDRESS(GPIO_15_BASE + (0x1 << (SDA_SHIFT_NUM + 2)))                                     /* 0x100 */
#define GPIO_I2C_SCLSDA_REG IO_ADDRESS(GPIO_15_BASE + ((0x1 << (SCL_SHIFT_NUM + 2)) + (0x1 << (SDA_SHIFT_NUM + 2)))) /* 0x300 need check */

#else
/*记得修改Makefile里面的路径*/
/*下面需要修改为对应芯片的*/
#define GPIO_15_BASE 0x120b1000 
#define SCL_SHIFT_NUM 4
#define SDA_SHIFT_NUM 5
/*上面需要修改为对应芯片的*/


#define SCL (0x1 << SCL_SHIFT_NUM)                                                                                   /* GPIO1 0_7 */
#define SDA (0x1 << SDA_SHIFT_NUM)                                                                                   /* GPIO1 0_6 */
void  * GPIO_I2C_SCL_REG; 
void  * GPIO_I2C_SDA_REG;
void  * GPIO_I2C_SCLSDA_REG; /* 0x300 need check */

#endif

void  *GPIO_0_DIR; 
#define HW_REG(reg) *((volatile unsigned int *)(reg))
#define DELAY(us) time_delay_us(us)

/* 
 * I2C by GPIO simulated  clear 0 routine.
 *
 * @param whichline: GPIO control line
 *
 */
static void i2c_clr(unsigned char whichline)
{
    unsigned char regvalue;

    if (whichline == SCL)
    {
        regvalue = HW_REG(GPIO_0_DIR);
        regvalue |= SCL;
        HW_REG(GPIO_0_DIR) = regvalue;

        HW_REG(GPIO_I2C_SCL_REG) = 0;
        return;
    }
    else if (whichline == SDA)
    {
        regvalue = HW_REG(GPIO_0_DIR);
        regvalue |= SDA;
        HW_REG(GPIO_0_DIR) = regvalue;

        HW_REG(GPIO_I2C_SDA_REG) = 0;
        return;
    }
    else if (whichline == (SDA | SCL))
    {
        regvalue = HW_REG(GPIO_0_DIR);
        regvalue |= (SDA | SCL);
        HW_REG(GPIO_0_DIR) = regvalue;

        HW_REG(GPIO_I2C_SCLSDA_REG) = 0;
        return;
    }
    else
    {
        printk("Error input.\n");
        return;
    }
}


/*
 *  delays for a specified number of micro seconds rountine.
 *
 *  @param usec: number of micro seconds to pause for
 *
 */
void time_delay_us(unsigned int usec)
{
    //	volatile int i,j;

#ifdef HI_FPGA
    for (i = 0; i < usec * 5; i++)
    {
        for (j = 0; j < 47; j++)
        {
            ;
        }
    }
#else
    udelay(usec * 60);

#endif
}
/* 
 * I2C by GPIO simulated  set 1 routine.
 *
 * @param whichline: GPIO control line
 *
 */
static void i2c_set(unsigned char whichline)
{
    unsigned char regvalue;

    if (whichline == SCL)
    {
        regvalue = HW_REG(GPIO_0_DIR);
        regvalue |= SCL;
        HW_REG(GPIO_0_DIR) = regvalue;

        HW_REG(GPIO_I2C_SCL_REG) = SCL;
        return;
    }
    else if (whichline == SDA)
    {
        regvalue = HW_REG(GPIO_0_DIR);
        regvalue |= SDA;
        HW_REG(GPIO_0_DIR) = regvalue;

        HW_REG(GPIO_I2C_SDA_REG) = SDA;
        return;
    }
    else if (whichline == (SDA | SCL))
    {
        regvalue = HW_REG(GPIO_0_DIR);
        regvalue |= (SDA | SCL);
        HW_REG(GPIO_0_DIR) = regvalue;

        HW_REG(GPIO_I2C_SCLSDA_REG) = (SDA | SCL);
        return;
    }
    else
    {
        printk("Error input.\n");
        return;
    }
}

/* 
 * I2C by GPIO simulated  read data routine.
 *
 * @return value: a bit for read 
 *
 */

static unsigned char i2c_data_read(void)
{
    unsigned char regvalue;

    regvalue = HW_REG(GPIO_0_DIR);
    regvalue &= (~SDA);
    HW_REG(GPIO_0_DIR) = regvalue;
    DELAY(1);

    regvalue = HW_REG(GPIO_I2C_SDA_REG);
    if ((regvalue & SDA) != 0)
        return 1;
    else
        return 0;
}

static void demo_i2c_start(void)
{
    // //out_scl();
    // //out_sda();
 
    high_scl;
 
    high_sda;
    demo_delay;
    low_sda;
    demo_delay;
 
    low_scl;
}
 
static void demo_i2c_stop(void)
{
    //out_scl();
    //out_sda();
 
    high_scl;
 
    low_sda;
    demo_delay;
    high_sda;
    demo_delay;
 
    low_scl;
}

/*
 * sends a character over I2C rountine.
 *
 * @param  c: character to send
 *
 */
static void demo_i2c_send_byte(unsigned char data)
{
    int i = 0;
    //out_scl();
    //out_sda();
 
    low_scl;
    for(i=0;i<8;i++) {
        if(data & (0x80>>i))
            high_sda;
        else
            low_sda;
        demo_delay;
        high_scl;
        demo_delay;
        low_scl;
    }
}

/*  receives a character from I2C rountine.
 *
 *  @return value: character received
 *
 */
static unsigned char demo_i2c_recv_byte(void)
{
    int i = 0;
    unsigned char data = 0;
    //out_scl();
    //in_sda();
 
    low_scl;
    for(i=0;i<8;i++) {
        demo_delay;
        high_scl;
        demo_delay;
        data <<= 1;//循环8次，最终只左移了7次
        data |= i2c_data_read();
        low_scl;
    }
    return data;
}


/*  receives an acknowledge from I2C rountine.
 *
 *  @return value: 0--Ack received; 1--Nack received
 *          
 */
static unsigned char demo_i2c_recv_ack(void)
{
    int nack;
    unsigned char regvalue;
    regvalue = HW_REG(GPIO_0_DIR);
    regvalue &= (~SDA);
    HW_REG(GPIO_0_DIR) = regvalue;

    //DELAY(1);
    i2c_clr(SCL);
    DELAY(1);
    i2c_set(SCL);
    DELAY(1);

    nack = i2c_data_read();

    DELAY(1);
    i2c_clr(SCL);
    DELAY(1);

    if (nack == 0)
    {
        return 0;
    }
    else
    {
        return 1;
    }
}


static void demo_i2c_send_ack(unsigned char ack)
{
    //out_scl();
    //out_sda();
    low_scl;
    if(ack)
        high_sda;
    else
        low_sda;
    demo_delay;
    high_scl;
    demo_delay;
    low_scl;
}


EXPORT_SYMBOL(gpio_i2c_read);
unsigned char gpio_i2c_read(unsigned char devaddress, unsigned char address)
{
    int i = 0,len=1;
    char buff;
 
    demo_i2c_start();
    demo_i2c_send_byte((unsigned char)(devaddress));
    if(demo_i2c_recv_ack()) {
        printk("data:0x%02x\n",(unsigned char)(devaddress));
        printk(KERN_WARNING "%d,get a nack.\n", __LINE__);
        return -1;
    }
    demo_i2c_send_byte(address & 0xff);
    if(demo_i2c_recv_ack()) {
        printk("address:0x%02x\n",address & 0xff);
        printk(KERN_WARNING "%d,get a nack.\n", __LINE__);
        return -1;
    }
 
    demo_i2c_start();
    demo_i2c_send_byte((unsigned char)(devaddress) | 1);
    if(demo_i2c_recv_ack()) {
        printk("devaddress:0x%02x\n",(unsigned char)(devaddress) | 1);
        printk(KERN_WARNING "%d,get a nack.\n", __LINE__);
        return -1;
    }
 
    for(i=0; i<(len-1); i++) {
        buff = demo_i2c_recv_byte();
        demo_i2c_send_ack(0);
    }
    buff = demo_i2c_recv_byte();
    demo_i2c_send_ack(1);
 
    demo_i2c_stop();
    return buff;
}

EXPORT_SYMBOL(gpio_i2c_write);
void gpio_i2c_write(unsigned char devaddress, unsigned int address, unsigned char data)
{
   int i = 0,len=1;
 
    demo_i2c_start();
    demo_i2c_send_byte((unsigned char)(devaddress));
    if(demo_i2c_recv_ack()) {
        printk(KERN_WARNING "%d,get a nack.\n", __LINE__);
        return -1;
    }
    demo_i2c_send_byte(address & 0xff);
    if(demo_i2c_recv_ack()) {
        printk(KERN_WARNING "%d,get a nack.\n", __LINE__);
        return -1;
    }
    for(i=0; i<len; i++) {
        demo_i2c_send_byte(data);
        if(demo_i2c_recv_ack()) {
            printk(KERN_WARNING "%d,get a nack.\n", __LINE__);
            return -1;
        }
    }
 
    demo_i2c_stop();
    return i;
}

#if 1
long gpioi2c_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    int ret;
    unsigned char device_addr;
    unsigned int reg_addr;
    unsigned int reg_val;
    GPIOI2C_DATA_S i2c_data_t;

    switch (cmd)
    {
    case GPIO_I2C_READ:
         ret=copy_from_user(&i2c_data_t, (GPIOI2C_DATA_S *)arg, sizeof(GPIOI2C_DATA_S));
        device_addr = i2c_data_t.dev_addr;
        reg_addr = i2c_data_t.reg_addr;
        i2c_data_t.data = gpio_i2c_read(device_addr, reg_addr);
        printk("GPIO_I2C_READ--device_addr:0x%02x  reg_addr:0x%02x  reg_val:0x%02x\n", device_addr, reg_addr,  i2c_data_t.data);
        ret=copy_to_user((GPIOI2C_DATA_S *)arg, &i2c_data_t, sizeof(GPIOI2C_DATA_S));
        break;

    case GPIO_I2C_SELCHN:

        break;

    case GPIO_I2C_WRITE:
        ret=copy_from_user(&i2c_data_t, (GPIOI2C_DATA_S *)arg, sizeof(GPIOI2C_DATA_S));
        device_addr = i2c_data_t.dev_addr;
        reg_addr = i2c_data_t.reg_addr;
        reg_val = i2c_data_t.data;
        gpio_i2c_write(device_addr, reg_addr, reg_val);
        break;
    case GPIO_I2C_WRITE2:
        ret=copy_from_user(&i2c_data_t, (GPIOI2C_DATA_S *)arg, sizeof(GPIOI2C_DATA_S));
        break;
    case GPIO_I2C_WRITE4:
        ret=copy_from_user(&i2c_data_t, (GPIOI2C_DATA_S *)arg, sizeof(GPIOI2C_DATA_S));
        break;

    default:
        printk("error!!%d\n", cmd);
        return -1;
    }
    return 0;
}

int gpioi2c_open(struct inode *inode, struct file *file)
{
    return 0;
}
int gpioi2c_close(struct inode *inode, struct file *file)
{
    return 0;
}

static struct file_operations gpioi2c_fops = {
    .owner = THIS_MODULE,
    //.ioctl      = gpioi2c_ioctl,
    .unlocked_ioctl = gpioi2c_ioctl,
    .open = gpioi2c_open,
    .release = gpioi2c_close};

static struct miscdevice gpioi2c_dev = {
    .minor = MISC_DYNAMIC_MINOR,
    .name = "gpioI2c",
    .fops = &gpioi2c_fops,
};

static int __init gpio_i2c_init(void)
{
    int ret;
    //unsigned int reg;
    GPIO_0_DIR=ioremap(GPIO_15_BASE + 0x400, 1); /* GPIO direction reg */
    GPIO_I2C_SCL_REG=ioremap(GPIO_15_BASE + (0x1 << (SCL_SHIFT_NUM + 2)), 1);                                     /* 0x200 */
    GPIO_I2C_SDA_REG=ioremap(GPIO_15_BASE + (0x1 << (SDA_SHIFT_NUM + 2)), 1);      
    GPIO_I2C_SCLSDA_REG=ioremap(GPIO_15_BASE + ((0x1 << (SCL_SHIFT_NUM + 2)) + (0x1 << (SDA_SHIFT_NUM + 2))), 1); 
    ret = misc_register(&gpioi2c_dev);
    if (0 != ret)
        return -1;
    return 0;
}

static void __exit gpio_i2c_exit(void)
{
    iounmap(GPIO_0_DIR); /* GPIO direction reg */
    iounmap(GPIO_I2C_SCL_REG);                                     /* 0x200 */
    iounmap(GPIO_I2C_SDA_REG);      
    iounmap(GPIO_I2C_SCLSDA_REG); 
    misc_deregister(&gpioi2c_dev);
}

module_init(gpio_i2c_init);
module_exit(gpio_i2c_exit);

#ifdef MODULE
//#include <linux/compile.h>
#endif
MODULE_LICENSE("GPL");
MODULE_AUTHOR("cb");
#endif

应用层：gpioApp.c

#include <stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include <linux/ioctl.h>
 
#pragma 0
 typedef struct {
	unsigned char  dev_addr;
	unsigned short reg_addr;
	unsigned char  addr_byte_num;
	unsigned int  data;
	unsigned char  data_byte_num;
}GPIOI2C_DATA_S;

 /* 定义幻数 */
#define MEMDEV_IOC_MAGIC  'k'
 
/* 定义命令 */
#define GPIO_I2C_READ   _IOWR(MEMDEV_IOC_MAGIC, 0x01,GPIOI2C_DATA_S)
#define GPIO_I2C_SELCHN   _IOWR(MEMDEV_IOC_MAGIC, 0x05,GPIOI2C_DATA_S)
#define GPIO_I2C_WRITE   _IOWR(MEMDEV_IOC_MAGIC, 0x03,GPIOI2C_DATA_S)
#define GPIO_I2C_WRITE2   _IOWR(MEMDEV_IOC_MAGIC, 0x07,GPIOI2C_DATA_S)
#define GPIO_I2C_WRITE4   _IOWR(MEMDEV_IOC_MAGIC, 0x09,GPIOI2C_DATA_S)
int main()
{
    int fd = 0;
    int cmd;
    GPIOI2C_DATA_S arg ;
    char Buf[4096];
    
    
    /*打开设备文件*/
    fd = open("/dev/gpioI2c",O_RDWR);
    if (fd < 0)
    {
        printf("Open Dev Mem0 Error!\n");
        return -1;
    }
    arg.addr_byte_num=0x00;
    arg.data_byte_num=0x00;
    arg.dev_addr=0x8c;
    arg.reg_addr=0x3a;
    arg.data=0x80;
    cmd = GPIO_I2C_WRITE;
    if (ioctl(fd, cmd, &arg) < 0)
        {
            printf("Call cmd MEMDEV_IOCPRINT fail\n");
            return -1;
    }
    arg.addr_byte_num=0x00;
    arg.data_byte_num=0x00;
    arg.dev_addr=0x8c;
    arg.reg_addr=0x3a;
    arg.data=0x00;
    cmd = GPIO_I2C_READ;
    if (ioctl(fd, cmd, &arg) < 0)
        {
            printf("Call cmd MEMDEV_IOCPRINT fail\n");
            return -1;
    }
    printf("read--device_addr:0x%02x  reg_addr:0x%02x  reg_val:0x%02x\n", arg.dev_addr, arg.reg_addr,  arg.data);

    arg.addr_byte_num=0x00;
    arg.data_byte_num=0x00;
    arg.dev_addr=0x8c;
    arg.reg_addr=0x3a;
    arg.data=0x13;
    cmd = GPIO_I2C_WRITE;
    if (ioctl(fd, cmd, &arg) < 0)
        {
            printf("Call cmd MEMDEV_IOCPRINT fail\n");
            return -1;
    }

    arg.addr_byte_num=0x00;
    arg.data_byte_num=0x00;
    arg.dev_addr=0x8c;
    arg.reg_addr=0x3a;
    arg.data=0x00;
    cmd = GPIO_I2C_READ;
    if (ioctl(fd, cmd, &arg) < 0)
        {
            printf("Call cmd MEMDEV_IOCPRINT fail\n");
            return -1;
    }
    printf("read1--device_addr:0x%02x  reg_addr:0x%02x  reg_val:0x%02x\n", arg.dev_addr, arg.reg_addr,  arg.data);
    close(fd);
    return 0;    
}

Makefile

obj-m += gpio_i2c.o

KDIR :=/home/dream/hi3556/Hi3559V200_SDK_V2.0.0.2/osdrv/opensource/kernel/linux-4.9.y-smp

PWD = $(shell pwd)
all:
	make ARCH=arm CROSS_COMPILE=arm-himix200-linux- -C $(KDIR) M=$(PWD) modules
	arm-himix200-linux-gcc -o gpioApp gpioApp.c
	cp gpio_i2c.ko gpioApp ~/share/视频上传
clean:
	make -C $(KDIR) M=$(PWD) clean

 

gpio_01
关注
  • 2
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
i2c驱动
weixin_44262171的博客
12-22 1009
I2C驱动 1、硬件 物理接线 I2C 总线在物理连接上非常简单，分别由 SDA(串行数据线)和SCL(串行时钟线)及上拉电阻组成。通信原理是通过对 SCL 和 SDA 线高低电平时序的控制，来产生 I2C 总线协议所需要的信号进行数据的传递。在总线空闲状态时，一般被所接的上拉电阻拉高，保持着高电平。 I2C总线特征 I2C 总线上的每一个设备都可以作为主设备或者从设备，而且每一个设备都会...
海思gpio模拟i2c驱动
06-19
海思普通IO口模拟I2C驱动 gpio模拟i2c驱动，修改makefile中的内核位置和寄存器地址
海思GPIO模拟I2C底层驱动，适应海思所有型号
05-24
海思GPIO模拟I2C底层驱动，修改makefile中的内核位置和寄存器地址即可适应海思所有型号。
海思平台gpio模拟i2c驱动源码
02-04
海思平台gpio模拟i2c驱动源码
linux gpio模拟i2c的使用/用GPIO模拟I2C总线-1
kevinx_xu的专栏
11-25 2256
linux kernel 中的i2c-gpio使用   在linux中，我们可以自己来使用gpio来模拟i2c，但是万能的linux中其实也已经有了i2c的东东了。   现在看看i2c-gpio.c文件中到底提供了哪些接口 [cpp] view plaincopy static void i2c_gpio_setsda_dir(void 
海思GPIO模拟I2C实现源码
09-10
海思GPIO模拟I2C实现源码，海思GPIO模拟I2C实现源码，大家可以下载学习一下，
i2c-driver.rar_LINUX 模拟I2C_Linux GPIO模拟i2c_海思 GPIO I2C_海思 gpio_海
09-22
在海思Hi3513平台上，由于I2C接口已被其他功能占用，开发者通常需要利用GPIO（General Purpose Input/Output）来模拟I2C接口以满足额外的需求。这个"I2C-driver.rar"压缩包提供的源代码正是实现这一功能的解决方案，...
GPIO模拟I2c
u012492340的专栏
11-05 248
#include <platform/gpio.h> #include <debug.h> #include <string.h> #include <smem.h> #include <err.h> #include <qtimer.h> #define SDA 10 #define SCL 11 #define OUT...
hisi gpio_i2c
one shot,one kill.
05-26 1262
GPIO5_6/I2C_SDA :pinmux =  0x120f_0000 +   0x17C         0为gpio5_6 GPIO5_7/I2C_SCL   = 0x120f_0000  +　0x180 0为gpio5_7 GPIO5  gpio_base_addr:  0x121A_0000 Table 13-18 Sum
用GPIO模拟I2C总线的通信过程及源代码
01-15
用GPIO模拟I2C总线的通信过程及源代码，在I2C总线不工作的情况下，SDA(数据线)和SCL(时钟线)上的信号均为高电平。如果此时主机需要发起新的通信请求，那么需要首先通过SDA和SCL发出起始标志。当SCL为高电平时，SDA电平从高变低，这一变化表示完成了通信的起始条件。
海思GPIO驱动程序
07-02
海思GPIO驱动程序，通过操作海思驱动设备，既可以控制海思的设备GPIO；
uboot使用软件i2c（IO模拟I2C）
weixin_41252596的博客
12-13 1056
uboot软件模拟i2c
GPIO引脚模拟实现软件I2C驱动
坚韧与专注
03-25 1537
GPIO 软件I2C 的实现
uboot移植i2c
喝水的面包
08-13 4640
uboot作为kernel启动的服务程序，内部支持很多的组件。部分需求会想让uboot支持eeprom存储或者rtc的功能支持，这样就需要uboot支持i2c的驱动。下下来的uboot里面就是有i2c的驱动例子的，这里就分析一下供移植模仿。 在uboot/drivers/i2c 下面就是几个i2c驱动的例子。 这里我们选择davinci_i2c.c来分析。这个是写的比较清楚和简单的。第一步我们需
GPIO模拟I2C程序实现
热门推荐
zhenwenxian的专栏
01-05 2万+
GPIO模拟I2C程序实现. I2C是由Philips公司发明的一种串行数据通信协议，仅使用两根信号线：SerialClock（简称SCL）和SerialData（简称SDA）。I2C是总线结构，1个Master，1个或多个Slave，各Slave设备以7位地址区分，地址后面再跟1位读写位，表示读（=1）或者写（=0），所以我们有时也可看到8位形式的设备地址，此时每个设备有读
Linux I2C驱动详解
Frake的博客
03-31 3834
本文基于mini2440开发板，Linux版本号是：linux-2.6.32.2 一.IIC总线device 硬件信息 #define S3C2410_PA_IIC (0x54000000) static struct resource s3c_i2c_resource[] = { [0] = { .start = S3C_PA_IIC, .end = S3C_PA_IIC +...
uboot 周立功 mx6g2c imx6ul io口模拟i2c 调试at24c512
linsheng_111的专栏
10-26 1034
关于 uboot 周立功 mx6g2c imx6ul io口模拟i2c 调试at24c512   cpu模块连接电路 uboot 使用i2c驱动 为如图 修改include/configs/mx6g2c.h文件、   修改 重新编译u-boot 测试i2c 功能 ...
BeagleBoneBlack学习（3）——U-Boot中的I2C驱动分析
hkchenhao的博客
04-12 3679
BeagleBoneBlack等TI开发板上都有一块eeprom芯片，u-boot根据eeprom芯片不同的内容对开发板进项配置，芯片属于I2C接口，下面对u-boot中的I2C驱动进行分析。在u-boot-2016.03中，i2c的初始化是在get_dpll_ddr_params（board/ti/am335x/board.c）函数中。 enable_i2c0_pin_mux()函数用于引脚
熟悉C语言，代码风格良好； 熟悉字符设备驱动框架的搭建； 熟悉linux内核中的并发与竞态的解决； 熟悉linux内核中断与中断底半部机制； 熟悉UART串口，I2c总线，SPI总线，platform总线； 了解u-boot，linux内核，设备树的移植； 了解ARM架构STM32MP157(Cotex-A7)GPIO,I2C,SPI驱动框架； 了解Linux下的 文件IO,标准IO的开发,多进程，多线程开发； 了解常用的链表，栈，队列等数据结构； 了解linux下的Socket网络编程,sqlite3数据库的使用； 了解shell和Makefile的基础知识，能编写简单的脚本； 了解HIMPP海思芯片和Rockchip瑞芯微芯片的媒体处理平台 API接口； 了解基于GStreamer流媒体处理框架的一些命令； 优化一下技能
最新发布
05-25
- 了解ARM架构STM32MP157(Cortex-A7)GPIO、I2C、SPI驱动框架，能够编写对应的驱动程序； - 熟悉Linux下的文件IO和标准IO开发，了解多进程和多线程编程，能够编写高效、可靠的应用程序； - 熟练掌握常用的数据结构，...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值