安霸平台gpio扩展芯片aw9523b调试

最新推荐文章于 2024-05-14 11:30:38 发布
最新推荐文章于 2024-05-14 11:30:38 发布
阅读量2.6k 收藏 8
点赞数 4
文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zuoanyouzhuan_/article/details/126286937
版权

公司的一个车载项目由于gpio扣较少，所以用了艾为的一颗16路gpio口扩展芯片，下面描述一下调试过程
硬件原理图如下
在这里插入图片描述
aw9523b芯片寄存器较少，直接自己写了个简单的gpio驱动，采用gpio子系统驱动，比较简单，下面是dts配置以及驱动源码

dts配置
 aw9523: aw9523@58 {
                                compatible = "awinic,aw9523_gpio";
                                aw9523_reset-gpios = <&gpio 82 0>;
                                reg = <0x58>;
                                gpio-controller;
                                interrupt-parent = <&gpio>;
                                interrupt-controller;
                                #gpio-cells = <2>;
                                interrupts = <14 0x0>;
                        };

驱动源码
// SPDX-License-Identifier: GPL-2.0+
/*
 * gpiolib support for Wolfson WM835x PMICs
 *
 * Copyright 2009 Wolfson Microelectronics PLC.
 *
 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
 *
 */

#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/gpio/driver.h>
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/init.h>
#include <linux/leds.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/gpio/consumer.h>
#include <linux/of_gpio.h>
#include <linux/gpio.h>
#include <linux/regulator/consumer.h>

/* aw9523 register */
#define AW9523_REG_CHIPID 0x10
#define AW9523_LED_MODE_P0 0x12
#define AW9523_LED_MODE_P1 0x13
#define AW9523_LED_MODE 0x00
#define AW9523_CHIPID 0x23
#define AW9523_REG_MAX 0x7F
#define AW9523_REG_BRIGHTNESS_BASE 0x20

struct aw9523_gpio {
	int aw9523_init_finished;
	int reset_gpio;
	struct gpio_desc *aw9523_rst_gpio;
	struct i2c_client *aw9523_client;
	struct gpio_chip aw9523_gpio_chip;
	struct device dev;
	spinlock_t lock;
};

static u8 reg_read(struct aw9523_gpio *aw9523_gpio_dev, u8 reg)
{
        u8 buf;
        int ret;
        struct i2c_msg msgs[] = {
                {
                        .addr  = aw9523_gpio_dev->aw9523_client->addr,
                        .flags = 0,
                        .len   = 1,
                        .buf   = &reg,
                }, {
                        .addr  = aw9523_gpio_dev->aw9523_client->addr,
                        .flags = I2C_M_RD,
                        .len   = 1,
                        .buf   = &buf,
                },
        };

        ret = i2c_transfer(aw9523_gpio_dev->aw9523_client->adapter, msgs, ARRAY_SIZE(msgs));
        if (ret < 0) {
                dev_err(&aw9523_gpio_dev->aw9523_client->dev, "aw9523 Reading register %x from %x failed\n",
                         reg, aw9523_gpio_dev->aw9523_client->addr);
                return ret;
        }

        return buf;
}

static int aw9523_read_reg(struct aw9523_gpio *aw9523_gpio_dev, u8 reg)
{
	int rc;

	rc = reg_read(aw9523_gpio_dev,reg);
	
		dev_err(&aw9523_gpio_dev->aw9523_client->dev,"aw9523 read reg = %02x, value = %02x****\n",reg,rc);
	rc = i2c_smbus_read_byte_data(aw9523_gpio_dev->aw9523_client, reg);
	if (rc < 0) {
		dev_err(&aw9523_gpio_dev->aw9523_client->dev,
			"<%s> can't read from %02x, i2c addr= %02x\n", __func__, reg, aw9523_gpio_dev->aw9523_client->addr);
		return -rc;
	}
	return rc;
}

static int aw9523_write_reg(struct aw9523_gpio *aw9523_gpio_dev, u8 reg, u8 val)
{
	int rc;

	rc = i2c_smbus_write_byte_data(aw9523_gpio_dev->aw9523_client, reg,
				       val);
	if (rc < 0) {
		dev_err(&aw9523_gpio_dev->aw9523_client->dev,
			"<%s> can't write %02x to %02x\n", __func__, val, reg);
		return -rc;
	}
	return 0;
}

static int aw9523_check_chipid(struct aw9523_gpio *aw9523_gpio_dev)
{
	u8 val;
	u8 cnt;

	for (cnt = 5; cnt > 0; cnt--) {
		val = aw9523_read_reg(aw9523_gpio_dev, AW9523_REG_CHIPID);
		dev_err(&aw9523_gpio_dev->aw9523_client->dev,
			"<%s> aw9523 chip id %0x\n", __func__, val);
		if (val == AW9523_CHIPID)
			return 0;
	}
	return -EINVAL;
}
int aw9523_gpio_get_value(struct aw9523_gpio *aw9523_gpio_dev, int port)
{
	u8 val;
	int value;

	if (aw9523_gpio_dev->aw9523_init_finished == 0) {
		dev_err(&aw9523_gpio_dev->aw9523_client->dev,
			"<%s> aw9523 is not inited\n", __func__);
		return -EPERM;
	}

	if (port < 0 || port > 15) {
		dev_err(&aw9523_gpio_dev->aw9523_client->dev,
			"<%s> invalid port: %d\n", __func__, port);
		return -EINVAL;
	}

	if (value != 0 && value != 1) {
		dev_err(&aw9523_gpio_dev->aw9523_client->dev,
			"<%s> invalid value\n", __func__);
		return -EINVAL;
	}

	val = (u8)aw9523_read_reg(aw9523_gpio_dev, 0x02 + port / 8);
	value = (val >> port) & 1;
	return value;
}

int aw9523_gpio_set_value(struct aw9523_gpio *aw9523_gpio_dev, int port,
			  int value)
{
	u8 val;

	if (aw9523_gpio_dev->aw9523_init_finished == 0) {
		dev_err(&aw9523_gpio_dev->aw9523_client->dev,
			"<%s> aw9523 is not inited\n", __func__);
		return -EPERM;
	}

	if (port < 0 || port > 15) {
		dev_err(&aw9523_gpio_dev->aw9523_client->dev,
			"<%s> invalid port: %d\n", __func__, port);
		return -EINVAL;
	}

	if (value != 0 && value != 1) {
		dev_err(&aw9523_gpio_dev->aw9523_client->dev,
			"<%s> invalid value\n", __func__);
		return -EINVAL;
	}

//	val = (u8)aw9523_read_reg(aw9523_gpio_dev, 0x02 + port / 8);

	if (value == 0)
		val &= ~(1 << (port % 8));
	else
		val |= 1 << (port % 8);

		dev_err(&aw9523_gpio_dev->aw9523_client->dev,
			"<%s> begin to write reg\n", __func__);

	return aw9523_write_reg(aw9523_gpio_dev, 0x02 + port / 8, val);
}

static int aw9523_gpio_get(struct gpio_chip *chip, unsigned int offset)
{
	int value;
	unsigned long flags;
	struct aw9523_gpio *aw9523_gpio_dev =
		container_of(chip, struct aw9523_gpio, aw9523_gpio_chip);

	spin_lock_irqsave(&aw9523_gpio_dev->lock, flags);
	value = aw9523_gpio_get_value(aw9523_gpio_dev, offset);
	spin_unlock_irqrestore(&aw9523_gpio_dev->lock, flags);

	return value;
}


static void aw9523_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
{
	unsigned long flags;
	struct aw9523_gpio *aw9523_gpio_dev =
		container_of(chip, struct aw9523_gpio, aw9523_gpio_chip);
	spin_lock_irqsave(&aw9523_gpio_dev->lock, flags);
	aw9523_gpio_set_value(aw9523_gpio_dev, offset, value);
	spin_unlock_irqrestore(&aw9523_gpio_dev->lock, flags);
}

static int aw9523_gpio_direction_out(struct gpio_chip *chip, unsigned offset,
				     int value)
{
	unsigned long flags;

	struct aw9523_gpio *aw9523_gpio_dev =
		container_of(chip, struct aw9523_gpio, aw9523_gpio_chip);

	spin_lock_irqsave(&aw9523_gpio_dev->lock, flags);
	dev_err(&aw9523_gpio_dev->aw9523_client->dev,
		"%s:offset = %d,value = %d\n", __func__, offset, value);

	aw9523_gpio_set_value(aw9523_gpio_dev, offset, value);
	spin_unlock_irqrestore(&aw9523_gpio_dev->lock, flags);
	return 0;
}

static ssize_t aw9523_gpio_store(struct device *dev,
               struct device_attribute *attr, const char *buf, size_t count)
{
       int rc;
       int port;
       int value;
       char port_buf[5];
       char value_buf[5];

       struct i2c_client *client =
                container_of(dev, struct i2c_client, dev);
       struct aw9523_gpio *aw9523_gpio_dev =
                i2c_get_clientdata(client);

       if (count < 2) {
               pr_err("<%s> invalid write string: %s\n", __func__, buf);
               return -EINVAL;
       }
       sscanf(buf,"%s %s",port_buf,value_buf);
       rc = kstrtouint(port_buf, 10, &port);
       rc = kstrtouint(value_buf, 10, &value);
	
       dev_err(dev, "%s:bing port = %d value = %d addr = %02x\n",__func__,port,value,aw9523_gpio_dev->aw9523_client->addr);
       rc = aw9523_gpio_set_value(aw9523_gpio_dev, port, value);
       return (rc == 0) ? count : -EINVAL;
}


static DEVICE_ATTR(aw9523_gpio, S_IWUSR | S_IWGRP, NULL, aw9523_gpio_store);

static int aw9523_gpio_probe(struct i2c_client *client,
			     const struct i2c_device_id *id)
{
	int ret;
	enum of_gpio_flags flags;
	int i;
	struct aw9523_gpio *aw9523_gpio_dev;
	
	aw9523_gpio_dev = devm_kzalloc(
		&client->dev, (sizeof(struct aw9523_gpio)), GFP_KERNEL);
	if (!aw9523_gpio_dev)
		return -ENOMEM;

	aw9523_gpio_dev->aw9523_client = client;
	aw9523_gpio_dev->aw9523_rst_gpio =
		devm_gpiod_get_optional(&client->dev, "aw9523_reset", 0);
	if (!aw9523_gpio_dev->aw9523_rst_gpio) {
		dev_err(&client->dev, "invalid  reset gpio\n");
		return -1;
	} else {
		gpiod_direction_output(aw9523_gpio_dev->aw9523_rst_gpio, 1);
		msleep(20);
		gpiod_direction_output(aw9523_gpio_dev->aw9523_rst_gpio, 0);
		msleep(30);
		gpiod_direction_output(aw9523_gpio_dev->aw9523_rst_gpio, 1);
		msleep(20);
	}

	aw9523_gpio_dev->aw9523_gpio_chip.label = "aw9523_gpio";
	aw9523_gpio_dev->aw9523_gpio_chip.owner = THIS_MODULE;
	aw9523_gpio_dev->aw9523_gpio_chip.direction_output =
		aw9523_gpio_direction_out;
	aw9523_gpio_dev->aw9523_gpio_chip.set = aw9523_gpio_set;
	aw9523_gpio_dev->aw9523_gpio_chip.get = aw9523_gpio_get;
	aw9523_gpio_dev->aw9523_gpio_chip.ngpio = 16;
	aw9523_gpio_dev->aw9523_gpio_chip.parent = &client->dev;
	aw9523_gpio_dev->aw9523_gpio_chip.base = -1;

	ret = devm_gpiochip_add_data(&client->dev,
				     &(aw9523_gpio_dev->aw9523_gpio_chip),
				     &(aw9523_gpio_dev->aw9523_gpio_chip));
	if (ret) {
		dev_err(&client->dev, "devm_gpiochip_add_data error\n");
		return -EINVAL;
	}

	ret = aw9523_check_chipid(aw9523_gpio_dev);
	if (ret) {
		dev_err(&client->dev, "Check chip id error\n");
		return -EINVAL;
	}
	// set P0 port as push-pull mode
	aw9523_write_reg(aw9523_gpio_dev, 0x11, 0x10);
	aw9523_write_reg(aw9523_gpio_dev, 0x12, 0xff);
	aw9523_write_reg(aw9523_gpio_dev, 0x13, 0xff);
	// P0 and P1 port output mode
	aw9523_write_reg(aw9523_gpio_dev, 0x04, 0x00);
	aw9523_write_reg(aw9523_gpio_dev, 0x05, 0x00);
	// disable interrupt function of P0 and P1 port
	aw9523_write_reg(aw9523_gpio_dev, 0x06, 0xff);
	aw9523_write_reg(aw9523_gpio_dev, 0x07, 0xff);
	// P0 and P1 port output low level
	aw9523_write_reg(aw9523_gpio_dev, 0x02, 0x00);
	aw9523_write_reg(aw9523_gpio_dev, 0x03, 0x00);

	
	spin_lock_init(&aw9523_gpio_dev->lock);
	aw9523_gpio_dev->aw9523_init_finished = 1;
	i2c_set_clientdata(client, aw9523_gpio_dev);
	
	ret = device_create_file(&client->dev, &dev_attr_aw9523_gpio);
        if (ret) {
               pr_err("<%s> create file aw9523_gpio failed\n", __func__);
               return -EPERM;
        }

	dev_err(&client->dev, "aw9523_probe succeeded\n");

	return 0;
}

static int aw9523_gpio_remove(struct i2c_client *client)
{
	return 0;
}

static const struct of_device_id aw9523_match_table[] = {
	{
		.compatible = "awinic,aw9523_gpio",
	},
	{},
};

static const struct i2c_device_id aw9523_id[] = {
	{ "awinic,aw9523_gpio", 0 },
	{},
};
MODULE_DEVICE_TABLE(i2c, aw9523_id);

static struct i2c_driver aw9523_driver = {
	.driver = {
		.name = "aw9523-gpio",
		.owner		= THIS_MODULE,
		.of_match_table = aw9523_match_table,
	},
	.probe    = aw9523_gpio_probe,
	.remove   = aw9523_gpio_remove,
	.id_table = aw9523_id,
};

module_i2c_driver(aw9523_driver);
MODULE_LICENSE("GPL V2");

```c
在这里插入代码片
zuoanyouzhuan_
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
富芮坤FR8008A II2C驱动之AW9523B
Joon2020的博客
08-27 1553
是一款I2C接口、16路呼吸灯,每路可作扩展 GPIO 控制器。上电后,16 路 GPIO 口默认为输出模式,其输出默认值可通过 2 位器件地址进行配置。AW9523B的I2C操作做了简单介绍，列举了扩展GPIO使用方法。配置GPIO,I2C，以及AW9523B复位操作。2.2 AW9523B 读函数。2.2 AW9523B 写函数。2.1 AW9523B初始化。操作P07的输出高低例子。...
RK3568-GPIO扩展-TCA9539/PCA9539驱动加载
荻夜的博客
05-30 1205
RK3568 加载 I2C 接口的 GPIO 扩展芯片（PCA9539）的驱动
AW9523 linux 按键驱动解析
大牛攻城狮的专栏
07-29 3977
#AW9523 linux 按键驱动解析 ##硬件介绍 AW9523是国产芯片，中文手册也是看着方便很多，我摘录一些编写驱动过程中重要信息贴到下面，当然，最好还是看芯片手册。 AW9523A 是一款 I2C 接口、 4 路呼吸灯及 16 路扩展 GPIO 控制器，它包含 16 路双向 GPIO 端口，其中 4 路可通过指令配置LED 驱动模式。 寄存器地址 W/R 默认值 功能 描述 00H R xxH Input_Port0 P0 口输入状态
驱动PCA9555扩展IO芯片
最新发布
qq_26043945的博客
05-14 1346
通用性：PCA9555是一款24引脚的CMOS器件，为I²C总线/SMBus应用提供16位通用并行输入/输出（GPIO）扩展。它旨在增强恩智浦半导体的I2C总线I/O扩展器系列，具有更高的驱动能力、5V I/O容差、更低的电源电流、独立的I/O配置和更小的封装。配置灵活性：PCA9555由两个8位配置（输入或输出选择）组成，包括输入、输出和极性反转（高电平有效或低电平有效操作）寄存器。系统控制器可以通过写入I/O配置位来启用I/O作为输入或输出。每个输入或输出的数据保存在相应的输入或输出寄存器中。
aw9523 gpio expander扩展芯片
MATLABCSD的博客
09-21 318
gpio扩展芯片驱动
I/O扩展器IC
kbq的博客
09-15 2414
PCA9555：此款芯片具有16路IO扩展，分为2组8位IO通道，每一个通道都可以单独设置为输入或者是输出模式，功能很强大。 PCA9505：这一款芯片驱动基本上与PCA9555相同，但是又有不同之处，控制上引脚多了OE输出使能控制引脚，多了RESET芯片复位引脚，寄存器上多了MSK中断配置寄存器，IO数量上扩展成了5组，共40个IO，地址还是A2 A1 A0三个，总线最多支持挂载8个芯片共320路IO控制，非常nice了。
PI4IOE5V6534 gpio扩展芯片linux驱动
u013463707的专栏
04-29 319
regmap的方式会有更新i2c寄存器不及时的问题，有时读取不更新，暂采用实时读取的方式 /* * Copyright (C) 2017 Texas Instruments Incorporated - http://www.ti.com/ * Keerthy <j-keerthy@ti.com> * * This program is free software; you can redistribute it and/or * modify it under the term.
安霸A9SE芯片资料.pdf
04-11
安霸A9SE图像处理芯片的产品规格简介，是官方文档。
安霸芯片设计的高清摄像头原理图和PCB技术资料
06-24
其中，安霸（Ambarella）芯片因其高效能、低功耗和出色的视频处理能力而备受青睐。本文将深入探讨安霸芯片在高清摄像头设计中的原理及PCB技术。 一、安霸芯片详解 安霸是一家专注于视频处理芯片的公司，其产品广泛...
安霸芯片资料汇总与对比
05-26
安霸芯片资料汇总与对比
安霸A9芯片资料Product-Brief.pdf
04-11
安霸A9的芯片简介资料，是安霸官方的芯片简介文档。
TCA6416A GPIO扩展芯片手册
09-01
GPIO扩展芯片，TCA6416A。
LED的C语言驱动代码
09-06
LED的C语言驱动代码
TI新款16位I2C I/O扩展器节省GPIO资源
11-28
德州仪器(TI)宣布推出三款16位可配置I2C和SMBus I/O扩展器，包括PCA9555、PCA9535以及1PCA9539，可为大多数微处理器(MPU)提供通用I/O扩展，帮助设计人员节省微处理器上的GPIO(通用输入/输出)。此外，这三款I2C从器件(slavedevice)利用了业界首选且符合RoHS标准的镍钯金(NiPdAu)镀层。 　　随着对功能以及处理不断提出更多要求，如LED控制、硬件监控器以及计算领域的湿度传感器等，微处理器上有限的GPIO越来越宝贵。通过采用TI的I/O扩展器，设计人员使用微处理器GPIO提供重要功能的同时，可利用16位I/O扩展器执行其它任务，包括系统监
通过IIC扩展GPIO口
05-05
用VHDL编写的，通过IIC扩展GPIO口，用lattice的FPGA作为从机。压缩包里面也有IIC协议文档。
安霸Ambarella_SOC_SPEC
09-24
Our solutions make cameras smarter by extracting valuable data from high-resolution video streams.
安霸A7LS芯片资料
07-16
安霸A7LS芯片资料，运动相机、行车记录仪等产品专用芯片
[RK3568 Android11]开发之PCA9535 GPIO扩展芯片调试
~未来可期~
03-27 8571
总目录链接：[RK3568 Android11] 本专栏说明和总目录 目录 前言 一、PCA9535芯片 1、芯片引脚定义 2、I2C地址 二、PCA9535驱动 1、PCA9535驱动说明 2、内核配置打开PCA9535驱动 3、DTS设备树配置 4、PCA9535驱动文件 5、PCA9535 GPIO实际使用 前言 RK3568芯片上的硬件资源是非常紧张，比如GPIO口不够使用时，这时就需要考虑使用GPIO扩展芯片来扩展GPIO口；GPIO扩展芯片有很多种，...
树莓派-LED篇
sK.坤
05-20 578
1 leds驱动 新增文件：arch\arm\boot\dts\overlays\example-overlay.dts /dts-v1/; /plugin/; /{ compatible = "brcm,bcm2835"; fragment@0 { target = <&gpio>; __overlay__ { leds_pins: leds_pins { brcm,pins = <25>; brcm,function = <1&gt..
安霸h22s75规格书：H22S75-DTS-003-0.1-Ambarella-Datasheet.pdf
02-02
美国音视频DSP芯片厂商ambarella，安霸H22S75规格书。 支持h265、最高可达4Kp30帧。支持电子防抖。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值