Android Hub 驱动

最新推荐文章于 2022-08-12 14:44:53 发布
最新推荐文章于 2022-08-12 14:44:53 发布
阅读量2.1k 收藏
点赞数
分类专栏： 内核编译 文章标签： android linux hub
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qin1137248135/article/details/122106645
版权

Makefile

KERNEL_DIR=/home/xxx/workspace/RK3399/soap/new_pro/P88/kernel
CURDIR=`pwd`

ARCH=arm64
CROSS_COMPILE=/home/xxx/workspace/RK3399/soap/new_pro/P88/prebuilts/gcc/linux-x86/aarch64/gcc-linaro-6.3.1-2017.05-x86_64_aarch64-linux-gnu/bin/aarch64-linux-gnu-
export  ARCH  CROSS_COMPILE

obj-m := husb_ala.o
all:
	make -C $(KERNEL_DIR) M=$(CURDIR) modules

.PHONE:clean cp

clean:
	$(MAKE) -C $(KERNEL_DIR) M=$(CURDIR) clean	

cp:
	sudo  cp  *.ko /home/nfs -rf

 

创建

husb_ala.c

#include <linux/i2c.h>
#include <linux/module.h>
#include <linux/of_device.h>
#include <linux/regmap.h>
#include <linux/slab.h>
#include <linux/of_gpio.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/gpio.h>

#define I2C_RETRY_NUMBER        1

struct husb311_ctrl
{
	int gpio;
	int irq;
	struct i2c_client * client;
};

static struct husb311_ctrl * g_husb311_ctrl = NULL;
static DEFINE_MUTEX(i2c_rw_access);

/**/


int husb311_i2c_read(struct i2c_client *client, char *writebuf, int writelen, char *readbuf, int readlen)
{
    int ret = 0;
    int i = 0;

    mutex_lock(&i2c_rw_access);

    if (readlen > 0) {
        if (writelen > 0) {
            struct i2c_msg msgs[] = {
                {
                    .addr = client->addr,
                    .flags = 0,
                    .len = writelen,
                    .buf = writebuf,
                },
                {
                    .addr = client->addr,
                    .flags = I2C_M_RD,
                    .len = readlen,
                    .buf = readbuf,
                },
            };
            for (i = 0; i < I2C_RETRY_NUMBER; i++) {
                ret = i2c_transfer(client->adapter, msgs, 2);
                if (ret < 0) {
                    printk(KERN_ERR "[IIC]: i2c_transfer(write) error, ret=%d ,client->addr=0x%x!!", ret,client->addr);
                } else
                    break;
            }
        } else {
            struct i2c_msg msgs[] = {
                {
                    .addr = client->addr,
                    .flags = I2C_M_RD,
                    .len = readlen,
                    .buf = readbuf,
                },
            };
            for (i = 0; i < I2C_RETRY_NUMBER; i++) {
                ret = i2c_transfer(client->adapter, msgs, 1);
                if (ret < 0) {
                    printk(KERN_ERR "[IIC]: i2c_transfer(read) error, ret=%d!!", ret);
                } else
                    break;
            }
        }
    }

    mutex_unlock(&i2c_rw_access);
    return ret;
}

int husb311_i2c_write(struct i2c_client *client, char *writebuf, int writelen)
{
    int ret = 0;
    int i = 0;

    mutex_lock(&i2c_rw_access);
    if (writelen > 0) {
        struct i2c_msg msgs[] = {
            {
                .addr = client->addr,
                .flags = 0,
                .len = writelen,
                .buf = writebuf,
            },
        };
        for (i = 0; i < I2C_RETRY_NUMBER; i++) {
            ret = i2c_transfer(client->adapter, msgs, 1);
            if (ret < 0) {
                printk(KERN_ERR "%s: i2c_transfer(write) error, ret=%d", __func__, ret);
            } else
                break;
        }
    }
    mutex_unlock(&i2c_rw_access);

    return ret;
}

int husb311_i2c_write_reg(struct i2c_client *client, unsigned char regaddr, unsigned char regvalue)
{
    unsigned char buf[2] = {0};
    buf[0] = regaddr;
    buf[1] = regvalue;
    return husb311_i2c_write(client, buf, sizeof(buf));
}

int husb311_i2c_read_reg(struct i2c_client *client, unsigned char regaddr, unsigned char *regvalue)
{
    return husb311_i2c_read(client, &regaddr, 1, regvalue, 1);
}



/**/


static int husb311_i2c_read_regs(struct i2c_client *client, unsigned char cmd, unsigned char *data, unsigned char data_len)
{
	struct i2c_msg msgs[2];
	int ret = -1;
	unsigned char * buffer = NULL;
	buffer = kzalloc(data_len, GFP_KERNEL);
	if (!buffer)
		return -ENOMEM;
	msgs[0].addr = client->addr;
	msgs[0].flags = client->flags;
	msgs[0].len = 1;
	msgs[0].buf = &cmd;

	msgs[1].addr = client->addr;
	msgs[1].flags = client->flags | I2C_M_RD;
	msgs[1].len = data_len;
	msgs[1].buf = buffer;
	ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
	if (ret < 0)
		dev_err(&client->adapter->dev, "i2c read failed\n");
	else
		memcpy(data, buffer, data_len);

	kfree(buffer);
	return ret;
}

static int husb311_i2c_write_regs(struct i2c_client *client, unsigned char cmd, unsigned char *data, unsigned char data_len)
{
	struct i2c_msg msgs[1];
	unsigned char *buffer;
	int ret = 0;
	buffer = kzalloc(data_len + 1, GFP_KERNEL);
	if (!buffer)
		return -ENOMEM;
	buffer[0] = cmd;
	memcpy(buffer + 1, data, data_len);
	msgs[0].addr = client->addr;
	msgs[0].flags = client->flags;
	msgs[0].len = data_len + 1;
	msgs[0].buf = buffer;
	ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
	if (ret < 0)
		dev_err(&client->adapter->dev, "i2c write failed\n");

	kfree(buffer);
	return ret;
}

static int husb311_i2c_write_reg(struct i2c_client *client, unsigned char reg, unsigned char value)
{
	unsigned char buf[2] = {'\0'};
	buf[0] = value;
	buf[1] = '\0';
	return husb311_i2c_write_regs(client, reg, buf, 1);
}

static unsigned char husb311_i2c_read_reg(struct i2c_client *client, unsigned char reg)
{
	int ret = -1;
	unsigned char buf[2] = {'\0'};
	ret = husb311_i2c_read_regs(client, reg, buf, 1);
	if (ret < 0)
	{
		printk(KERN_ERR "husb311_i2c_read_regs 0x%x fail\n", reg);
		return -1;
	}
	return buf[0];
}


static int husb311_init(struct i2c_client * client)
{
	int ret = -1;
	//unsigned char value = 0;
	//unsigned char i = 0;
	ret = husb311_i2c_write_reg(client, 0xA0, 0x1);
	if (ret < 0)
	{
		printk(KERN_ERR "husb311_i2c_write_reg 0xA0 fail\n");
		return -1;
	}

	for (;;)
	{
		ret = husb311_i2c_read_reg(client, 0x1E, &value);
		if (ret)
		{
			printk(KERN_ERR "time out!!!\n");
			return -1;
		}
		if (!(value & (1 << 6)) || (i > 20))
		{
			break;
		}
		msleep(100);
		i++;
	}
	if (i > 20)
	{
		printk(KERN_ERR "time out!!!\n");
		return -1;
	}
	ret = husb311_i2c_write_reg(client, 0x10, 0xff);
	if (ret < 0)
	{
		printk(KERN_ERR "husb311_i2c_write_reg 0x10 fail\n");
		return -1;
	}
	ret = husb311_i2c_write_reg(client, 0x11, 0xff);
	if (ret < 0)
	{
		printk(KERN_ERR "husb311_i2c_write_reg 0x11 fail\n");
		return -1;
	}
	ret = husb311_i2c_write_reg(client, 0x12, 0x1);
	if (ret < 0)
	{
		printk(KERN_ERR "husb311_i2c_write_reg 0x12 fail\n");
		return -1;
	}	
	ret = husb311_i2c_write_reg(client, 0x13, 0x0);
	if (ret < 0)
	{
		printk(KERN_ERR "husb311_i2c_write_reg 0x13 fail\n");
		return -1;
	}	
	ret = husb311_i2c_write_reg(client, 0x14, 0x0);
	if (ret < 0)
	{
		printk(KERN_ERR "husb311_i2c_write_reg 0x14 fail\n");
		return -1;
	}	
	ret = husb311_i2c_write_reg(client, 0x90, 0x2);
	if (ret < 0)
	{
		printk(KERN_ERR "husb311_i2c_write_reg 0x90 fail\n");
		return -1;
	}	
	ret = husb311_i2c_write_reg(client, 0x9f, 0x0);
	if (ret < 0)
	{
		printk(KERN_ERR "husb311_i2c_write_reg 0x9f fail\n");
		return -1;
	}
	ret = husb311_i2c_write_reg(client, 0x1a, 0xa);
	if (ret < 0)
	{
		printk(KERN_ERR "husb311_i2c_write_reg 0x1a fail\n");
		return -1;
	}

	return 0;
}

static void husb311_func(struct work_struct * work)
{
	unsigned char value = 0;
	int ret = husb311_i2c_read_reg(g_husb311_ctrl->client, 0x10, &value);
	if (ret)
	{
		printk(KERN_ERR "husb311_i2c_write_reg 0x10 fail\n");
		return;
	}
	if (value &(1 << 0))
	{
		ret = husb311_i2c_read_reg(g_husb311_ctrl->client, 0x1d, &value);
		if (ret)
		{
			printk(KERN_ERR "husb311_i2c_write_reg 0x1d fail\n");
			return;
		}
		if ((value & (0x3 << 2)) && ((value & (0x3 << 0))==0x0))
		{
			printk(KERN_ERR "CC2 is connect!!!");
		}
		if ((value & (0x3 << 0)) && ((value & (0x3 << 2))==0x0))
		{
			printk(KERN_ERR "CC1 is connect!!!");

		}
		husb311_i2c_write_reg(g_husb311_ctrl->client, 0x10, 0xff);
		husb311_i2c_write_reg(g_husb311_ctrl->client, 0x11, 0xff);
	}
	enable_irq(g_husb311_ctrl->irq);
}
static DECLARE_WORK(husb311_work, husb311_func);

static irqreturn_t husb311_irq_handler(int irq, void *dev_id)
{
	printk(KERN_ERR "------------husb311_irq_handler-------------\n");
	schedule_work(&husb311_work);
	disable_irq(g_husb311_ctrl->irq);
	return IRQ_HANDLED;
}

static int husb311_probe(struct i2c_client *client,
			 const struct i2c_device_id *id)
{
	int ret = -1;
	enum of_gpio_flags irq_flags;
	struct device_node * np = client->dev.of_node;
	printk(KERN_ERR "------------enter probe function-------------\n");
	g_husb311_ctrl = kzalloc(sizeof(struct husb311_ctrl), GFP_KERNEL);
	if (!g_husb311_ctrl)
	{
		printk(KERN_ERR "kzalloc fail\n");
		return -ENOMEM;
	}
	g_husb311_ctrl->client = client;
	g_husb311_ctrl->gpio = of_get_named_gpio_flags(np, "int-n-gpios", 0, (enum of_gpio_flags*)&irq_flags);
	if (g_husb311_ctrl->gpio < 0)
	{
		printk(KERN_ERR "of_get_named_gpio_flags fail\n");
		goto gpio_err;
	}

	printk(KERN_ERR "gpio:%d\n", g_husb311_ctrl->gpio);

	ret = gpio_request(g_husb311_ctrl->gpio, "husb311 irq gpio");
	if (ret < 0)
	{
		printk(KERN_ERR "gpio_request fail\n");
		goto gpio_request_err;
	}
	g_husb311_ctrl->irq = gpio_to_irq(g_husb311_ctrl->gpio);
	if (g_husb311_ctrl->irq < 0)
	{
		printk(KERN_ERR "gpio_to_irq fail\n");
		goto to_irq_err;
	}

	printk(KERN_ERR "irq:%d\n", g_husb311_ctrl->irq);

	ret = request_irq(g_husb311_ctrl->irq, husb311_irq_handler, irq_flags,
	"husb311_irq", NULL);

	printk(KERN_ERR "request_irq return:%d\n", ret);
	if (ret != 0)
	{
		printk(KERN_ERR "request_irq fail\n");
		goto request_irq_err;
	}

	/* init */
	ret = husb311_init(client);
	if (ret < 0)
	{
		printk(KERN_ERR "husb311_init fail\n");
		goto husb311_init_err;
	}
	return 0;

husb311_init_err:
	free_irq(g_husb311_ctrl->irq, NULL);
request_irq_err:
to_irq_err:
	gpio_free(g_husb311_ctrl->gpio);
gpio_request_err:
gpio_err:
	return -1;
}

static int husb311_remove(struct i2c_client *client)
{
	free_irq(g_husb311_ctrl->irq, NULL);
	gpio_free(g_husb311_ctrl->gpio);
	return 0;
}

static const struct of_device_id husb311_of_match[] = {
	{ .compatible = "husb311" },
	{ },
};

static const struct i2c_device_id husb30x[] = {
	{ "husb311", 0 },
	{}
};
MODULE_DEVICE_TABLE(i2c, husb30x);

static struct i2c_driver husb311_i2c_driver = {
	.driver = {
		.name = "husb311",
		.of_match_table = husb311_of_match,
	},
	.probe    = husb311_probe,
	.remove   = husb311_remove,
	.id_table = husb30x,
};

module_i2c_driver(husb311_i2c_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("linqi");
MODULE_DESCRIPTION("husb311 usb cc driver");

qin1137248135
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
android手机usb驱动程序 免费版
07-11
Android手机USB数据线驱动是专为安卓手机提供的一款驱动程序，安装驱动后，用户可将手机与电脑正常连接，实现电脑与手机资料同步功能，兼容Android2.3以上的系统，欢迎下载！驱动说明目前市场上部分手机需要安装驱动才能连接电脑，因此有很多手机是,欢迎下载体验
usb hub驱动
chenliang0224的专栏
03-25 5190
1. hub驱动流程图2. hub驱动初始化 retval = usb_hub_init(); int usb_hub_init(void) { if (usb_register(&amp;hub_driver) &lt; 0) { //注册hub驱动到usb子系统总线上 printk(KERN_ERR "%s: can't register hub driver\n", usbcor...
安卓P，sensorhub上可以直接使用
11-28
MT6761 MT6762 sensorhub ，sc7a20sensor，可直接用的驱动文件
OpenHub——一个开源的GitHub Android客户端，快速简洁
热门推荐
30度的射线的博客
09-08 1万+
一个开源的GitHub Android客户端，快速简洁，支持主题、主颜色、语言切换，SO COOL的语法高亮。
安卓车机线刷软件加驱动.rar
01-04
线刷工具，救砖神器
MTK的android驱动移植
最新发布
12-18
MTK的Android驱动移植主要涉及的是在MediaTek芯片平台上对Android操作系统的驱动程序进行适配和优化的过程。MediaTek是一个知名的芯片制造商，提供多种不同型号的处理器，如MT6575、MT6573等，这些处理器常用于智能...
指南针QMC6308 mtk sensorhub 平台驱动
11-20
综上所述，QMC6308在MTK sensorhub平台上的驱动开发涉及硬件接口设计、驱动程序编写、sensorhub通信以及与Android系统的深度整合。理解这些知识点对于开发者来说至关重要，能够帮助他们构建出高效、稳定的地磁传感器...
Android 事件驱动流程
04-01
在Android系统中，事件驱动流程是其用户界面交互的核心机制，特别是对于输入事件的处理，如触摸屏操作、按键点击等。Android输入事件处理流程主要涉及Boot过程、系统服务启动、窗口管理服务（WindowManagerService）...
加速度QMA6981 驱动
11-20
MTK6737是一款由联发科（Mediatek）制造的四核64位处理器，广泛应用于入门级和中端Android设备。对于QMA6981驱动的支持意味着该处理器能够充分利用传感器的能力，提供用户友好的体验。 在提供的文件列表中，我们...
Linux下Android ADB驱动安装详解
09-23
Linux 下 Android ADB 驱动安装详解 在 Linux 操作系统中安装 Android ADB 驱动是一个复杂的过程，需要对相关知识点有深入的理解。在本文中，我们将详细介绍 Linux 下 Android ADB 驱动安装的步骤和可能遇到的问题...
Microsoft Azure IoTHub Serials 2 - 如何为android应用添加IoTHub支持
weixin_33753845的博客
05-23 128
1. 在build.gradle（app）文件的dependencies中添加对以下项的依赖： 'com.microsoft.azure.sdk.iot:iot-device-client:1.5.37'   其中后面的1.5.37是版本号，最新的版本可以到这里查： http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.microsof...
USB gadget 驱动之 android.c
weixin_42129680的博客
03-09 3594
PD3.1 140W双C快充解决方案
Hynetek的博客
08-12 3166
第一批支持USB PD3.1的设备是苹果公司推出的2021 Macbook Pro，它支持140W的USB-C快充。面向这种百瓦以上的快充需求，慧能泰顺势推出了140W的双C口快充电源方案，该方案通过两颗HUSB311实现。
USB hub驱动分析(1)--硬件篇
wocao1226的专栏
06-13 5041
USB hub驱动分析(1)--硬件篇        最近在调试usb 功能设备驱动程序，包括hid类设备和audio等。发现很多问题都卡在了HUB的分离处理传输上，不知道是主机控制器兼容性的问题还是配置不对，在周期传输中hub总会出现各种各样的问题。趁着周末好好把hub这块基本的流程看一下。        硬件上主要就是hub芯片了，host接口直接引到上行端口，然后分4
Android 输入系统之EventHub篇
愿景的博客
11-09 7041
做Android系统定制两年多了，受到别人启发，将自己的学习工作经历整理成博客，供以后重温，好了废话不多说，这段时间研究了下Android的输入系统，深深的感叹Android系统的庞大。。。。。。 Android所有的input设备都会在/dev/input目录下生成对应的设备节点，一旦有任何输入事件产生，便会将事件写到这些节点下，同时对于外部输入设备（鼠标键盘等）的插拔还会引起这些节点
USB学习5---android usb驱动源代码目录说明
LoongEmbedded的专栏
12-21 4335
kernel\msm-3.18\drivers\usb下目录内容   我们msm8937+android7.1平台编译out目录下usb目录下有编译到的目录如下： 我们先参考kernel\msm-3.18\drivers\usb\README对这些部分的介绍。列举了一下usb目录各个文件有什么作用。接下来就是看Kconfig、Makefile文件的内容了。任何linux下驱动模块都必...
USB hub驱动分析
pumpkinhill的专栏
11-08 3309
最近在调试usb 功能设备驱动程序，包括hid类设备和audio等。发现很多问题都卡在了HUB的分离处理传输上，不知道是主机控制器兼容性的问题还是配置不对，在周期传输中hub总会出现各种各样的问题。趁着周末好好把hub这块基本的流程看一下。        硬件上主要就是hub芯片了，host接口直接引到上行端口，然后分4路引出：直接外接设备。另外MiniAB接口通过OTG转接线分为Adevi
usb hub芯片 android,usb hub芯片GL850G详解
weixin_39572794的博客
05-28 3145
GL850G拥有低耗电、温度低及接脚数减少等产品特性。它支援4个下游连接埠，可完全支援USB2.0/1.1规格，因此无论是与主机端或是与其他USB设备介面的传输连接(高速/全速/低速设备传输)皆能完 全相容。GL850G同时拥有过载保护功能，提供良好的EMI/ESD处理，亦提供self-power及bus-power自动侦测模式，使用者将无需 作重新插拔的动作。由于集线器为电脑主机与周边设备的中继...
root hub usb设备和驱动的匹配(五)
Frake的博客
04-28 1969
注册driver的函数是driver_register，device_driver传参如下： new_udriver->drvwrap.for_devices = 1; new_udriver->drvwrap.driver.name = (char *) new_udriver->name; new_udriver->drvwrap.driver.bus = &u...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值