展会信息港展会大全

Android模拟器学framework和driver之battery & backlight-----1.battery in linux
来源:互联网   发布日期:2016-01-14 15:04:23   浏览:2407次  

导读:在linux中battery驱动主要是去处理供电方面的东西,大家看下driver在bsp中的路径就可以知道,android模拟器使用的goldfish内核中battery驱动的位置是:and...

在linux中battery驱动主要是去处理供电方面的东西,大家看下driver在bsp中的路径就可以知道,android模拟器使用的goldfish内核中battery驱动的位置是:

android/common/drivers/power/goldfish_battery.c

目前手机,平板电脑日益普及,在嵌入式领域battery的续航能力也一直制约着手机等嵌入式设备的发展,iphone比android手机做的好多了,希望android可以再处理上下功夫,赶超apple,废话不多说,这里battery主要是处理,电池供电、插上充电器充电、USB供电等事情的发生,还有就是一些电池的信息管理,比如说电量、温度等状态可以使用户知道。

OK,这边我们主要是使用goldfish中的battery驱动来分析一下linux中的power模块是如何工作的。

在这之前我们首先要来看一下power_supply这个device driver 子系统是如何建立的,这边我们涉及到的代码都在/common/drivers/power/下:

power_supply_core.c

power_supply_sysfs.c

goldfish_battery.c

power_supply_core.c是power_supple subsystem的核心函数,在power_supply子系统在linux启动的时候会先调用到里面的饿init函数:

[cpp]

static int __init power_supply_class_init(void)

{

power_supply_class = class_create(THIS_MODULE, "power_supply");

if (IS_ERR(power_supply_class))

return PTR_ERR(power_supply_class);

power_supply_class->dev_uevent = power_supply_uevent;

return 0;

}

subsys_initcall(power_supply_class_init);

这个函数比较简单首先是在class中创建了一个power_supply的class,启动模拟器后可以看到在sys/class/下会有一个power_supply文件夹生成,然后是

power_supply_class->dev_uevent = power_supply_uevent;这句话把power_supply_uevent挂到power_supply_class的dev_uevent上,这里说明下,就是说power_supply子系统都是使用uevent机制把信息传到user space的,当battery的状态发生改变的时候会向用户空间上报一个uevent,这样的话用户空间就可以知道什么时候去抓信息。

这个power_supply_uevent是个回调函数,被定义在power_supply_sysfs.c中:

[cpp]

int power_supply_uevent(struct device *dev, struct kobj_uevent_env *env)

{

struct power_supply *psy = dev_get_drvdata(dev);

int ret = 0, j;

char *prop_buf;

char *attrname;

dev_dbg(dev, "uevent\n");

if (!psy || !psy->dev) {

dev_dbg(dev, "No power supply yet\n");

return ret;

}

dev_dbg(dev, "POWER_SUPPLY_NAME=%s\n", psy->name);

ret = add_uevent_var(env, "POWER_SUPPLY_NAME=%s", psy->name);

if (ret)

return ret;

prop_buf = (char *)get_zeroed_page(GFP_KERNEL);

if (!prop_buf)

return -ENOMEM;

for (j = 0; j < ARRAY_SIZE(power_supply_static_attrs); j++) {

struct device_attribute *attr;

char *line;

attr = &power_supply_static_attrs[j];

ret = power_supply_show_static_attrs(dev, attr, prop_buf);

if (ret < 0)

goto out;

line = strchr(prop_buf, '\n');

if (line)

*line = 0;

attrname = kstruprdup(attr->attr.name, GFP_KERNEL);

if (!attrname) {

ret = -ENOMEM;

goto out;

}

dev_dbg(dev, "Static prop %s=%s\n", attrname, prop_buf);

ret = add_uevent_var(env, "POWER_SUPPLY_%s=%s", attrname, prop_buf);

kfree(attrname);

if (ret)

goto out;

}

dev_dbg(dev, "%zd dynamic props\n", psy->num_properties);

for (j = 0; j < psy->num_properties; j++) {

struct device_attribute *attr;

char *line;

attr = &power_supply_attrs[psy->properties[j]];

ret = power_supply_show_property(dev, attr, prop_buf);

if (ret == -ENODEV) {

/* When a battery is absent, we expect -ENODEV. Don't abort;

send the uevent with at least the the PRESENT=0 property */

ret = 0;

continue;

}

if (ret < 0)

goto out;

line = strchr(prop_buf, '\n');

if (line)

*line = 0;

attrname = kstruprdup(attr->attr.name, GFP_KERNEL);

if (!attrname) {

ret = -ENOMEM;

goto out;

}

dev_dbg(dev, "prop %s=%s\n", attrname, prop_buf);

ret = add_uevent_var(env, "POWER_SUPPLY_%s=%s", attrname, prop_buf);

kfree(attrname);

if (ret)

goto out;

}

out:

free_page((unsigned long)prop_buf);

return ret;

}

稍微有点长,不怕,我们慢慢来分析,这里只是开头,什么都没有应该比较好分析,

我们抓重点,首先是ret = add_uevent_var(env, "POWER_SUPPLY_NAME=%s", psy->name);这句话添加了uevent的一些环境变量,这里添加了POWER_SUPPLY_NAME,接着都是些分配内存的代码,还有就是把power_supply_properties中注册的所有属性都添加成环境变量,这样的话当battery的某个属性发生变化的时候都会通报到上层让用户知道。

这里uevent我不做详细介绍,网上资料也一大堆,后面讲到jni层的时候我也会做补充用户层是如何去开启一个socket来抓kernel中的uevent的。

回到我们的power_supply_core.c中,在linux起来的时候只有调用到core中的class_init函数,其他的函数都是为我们的driver服务的,

现在我们来看下我们的goldfish_battery驱动,打开android/common/drivers/power/goldfish_battery.c,一般我喜欢先看init函数,

[cpp]

static int __init goldfish_battery_init(void)

{

return platform_driver_register(&goldfish_battery_device);

}

很简单,注册了platform_driver,同学们看到了这个函数第一反应应该是去找device_register函数,以为只有这2个函数匹配了才算在linux系统中注册了platform 设备,那么在哪呢?在我们goldfish的板级文件中有注册device,这边很奇怪,其实我没有找到具体的goldfish-battery的device_register但是在板级文件中有一个pdev_bus的注册

arch/arm/mach-goldfish/pdev_bus.c

[cpp]

static void goldfish_pdev_worker(struct work_struct *work);

static uint32_t pdev_bus_base;

static uint32_t pdev_bus_irq;

static LIST_HEAD(pdev_bus_new_devices);

static LIST_HEAD(pdev_bus_registered_devices);

static LIST_HEAD(pdev_bus_removed_devices);

static DECLARE_WORK(pdev_bus_worker, goldfish_pdev_worker);

static void goldfish_pdev_worker(struct work_struct *work)

{

int ret;

struct pdev_bus_dev *pos, *n;

list_for_each_entry_safe(pos, n, &pdev_bus_removed_devices, list) {

list_del(&pos->list);

platform_device_unregister(&pos->pdev);

kfree(pos);

}

list_for_each_entry_safe(pos, n, &pdev_bus_new_devices, list) {

list_del(&pos->list);

<span style="color: rgb(255, 0, 0); ">ret = platform_device_register(&pos->pdev);</span>

if(ret) {

printk("goldfish_pdev_worker failed to register device, %s\n", pos->pdev.name);

}

else {

printk("goldfish_pdev_worker registered %s\n", pos->pdev.name);

}

list_add_tail(&pos->list, &pdev_bus_registered_devices);

}

}

可以看下上面这个代码中,在工作队列中遍历所有的pdev链表,调用platform_device_register把设备注册进去,之后就会调用到我们的probe函数了。

---------------------------------------------------------------------------------

probe函数主要还是做一些初始化,probe的意思就是探测的意思,就是试着去初始化(我是这么理解的),

[cpp]

static int goldfish_battery_probe(struct platform_device *pdev)

{

int ret;

struct resource *r;

struct goldfish_battery_data *data;

data = kzalloc(sizeof(*data), GFP_KERNEL);

if (data == NULL) {

ret = -ENOMEM;

goto err_data_alloc_failed;

}

spin_lock_init(&data->lock);

data->battery.properties = goldfish_battery_props;

data->battery.num_properties = ARRAY_SIZE(goldfish_battery_props);

data->battery.get_property = goldfish_battery_get_property;

data->battery.name = "battery";

data->battery.type = POWER_SUPPLY_TYPE_BATTERY;

data->ac.properties = goldfish_ac_props;

data->ac.num_properties = ARRAY_SIZE(goldfish_ac_props);

data->ac.get_property = goldfish_ac_get_property;

data->ac.name = "ac";

data->ac.type = POWER_SUPPLY_TYPE_MAINS;

r = platform_get_resource(pdev, IORESOURCE_MEM, 0);

if (r == NULL) {

printk(KERN_ERR "%s: platform_get_resource failed\n", pdev->name);

ret = -ENODEV;

goto err_no_io_base;

}

data->reg_base = IO_ADDRESS(r->start - IO_START);

data->irq = platform_get_irq(pdev, 0);

if (data->irq < 0) {

printk(KERN_ERR "%s: platform_get_irq failed\n", pdev->name);

ret = -ENODEV;

goto err_no_irq;

}

ret = request_irq(data->irq, goldfish_battery_interrupt, IRQF_SHARED, pdev->name, data);

if (ret)

goto err_request_irq_failed;

ret = power_supply_register(&pdev->dev, &data->ac);

if (ret)

goto err_ac_failed;

ret = power_supply_register(&pdev->dev, &data->battery);

if (ret)

goto err_battery_failed;

platform_set_drvdata(pdev, data);

battery_data = data;

GOLDFISH_BATTERY_WRITE(data, BATTERY_INT_ENABLE, BATTERY_INT_MASK);

return 0;

err_battery_failed:

power_supply_unregister(&data->ac);

err_ac_failed:

free_irq(data->irq, data);

err_request_irq_failed:

err_no_irq:

err_no_io_base:

kfree(data);

err_data_alloc_failed:

return ret;

}

首先来看几个结构体,其实个人认为,linux驱动给开发人员做的很多就是填充结构体,因为基本框架linux已经实现了,我们要做的是把这个大框架填满,使这个框架有血有肉,这样才能正常工作。

首先是goldfish_battery_data 这个结构体:

[cpp]

struct goldfish_battery_data {

uint32_t reg_base;

int irq;

spinlock_t lock;

struct power_supply battery;

struct power_supply ac;

};

这个结构体中我们关注的是power_supply这个结构体,别的没什么好说的,中断啊,寄存器地址啊,自旋锁什么的。

[cpp]

struct power_supply {

const char *name;

enum power_supply_type type;

enum power_supply_property *properties;

size_t num_properties;

char **supplied_to;

size_t num_supplicants;

int (*get_property)(struct power_supply *psy,

enum power_supply_property psp,

union power_supply_propval *val);

void (*external_power_changed)(struct power_supply *psy);

/* For APM emulation, think legacy userspace. */

int use_for_apm;

/* private */

struct device *dev;

struct work_struct changed_work;

#ifdef CONFIG_LEDS_TRIGGERS

struct led_trigger *charging_full_trig;

char *charging_full_trig_name;

struct led_trigger *charging_trig;

char *charging_trig_name;

struct led_trigger *full_trig;

char *full_trig_name;

struct led_trigger *online_trig;

char *online_trig_name;

#endif

};

这部分我们对照着probe中的代码一起分析,主要还是填充这个结构体:

[cpp]

data->battery.properties = goldfish_battery_props;

data->battery.num_properties = ARRAY_SIZE(goldfish_battery_props);

data->battery.get_property = goldfish_battery_get_property;

data->battery.name = "battery";

data->battery.type = POWER_SUPPLY_TYPE_BATTERY;

首先是对battery的属性信息的填写:

[cpp]

static enum power_supply_property goldfish_battery_props[] = {

POWER_SUPPLY_PROP_STATUS,

POWER_SUPPLY_PROP_HEALTH,

POWER_SUPPLY_PROP_PRESENT,

POWER_SUPPLY_PROP_TECHNOLOGY,

POWER_SUPPLY_PROP_CAPACITY,

};

这边电池的信息由status health present等,我们比较关注的还是电池的电量,capacity,

然后是属性的数目,不多说了,下面第三个参数比较重要 data->battery.get_property = goldfish_battery_get_property;

[cpp]

static int goldfish_battery_get_property(struct power_supply *psy,

enum power_supply_property psp,

union power_supply_propval *val)

{

struct goldfish_battery_data *data = container_of(psy,

struct goldfish_battery_data, battery);

int ret = 0;

switch (psp) {

case POWER_SUPPLY_PROP_STATUS:

//modify charge to discharge

//val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_STATUS);

val->intval = POWER_SUPPLY_STATUS_DISCHARGING;

//-----modify end

break;

case POWER_SUPPLY_PROP_HEALTH:

val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_HEALTH);

break;

case POWER_SUPPLY_PROP_PRESENT:

val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_PRESENT);

break;

case POWER_SUPPLY_PROP_TECHNOLOGY:

val->intval = POWER_SUPPLY_TECHNOLOGY_LION;

break;

case POWER_SUPPLY_PROP_CAPACITY:

//modify capacity from 50 per to 20 per by Jay

//val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_CAPACITY);

val->intval = global_brightness;

//----modify end

break;

default:

ret = -EINVAL;

break;

}

return ret;

}

驱动中就是通过这个函数去实时得到电池的信息,然后使用uevent传到user space,我们重点讲下这个函数是怎么工作的。

大家注意到这里这个函数的参数,struct power_supply *psy,

enum power_supply_property psp,

union power_supply_propval *val

第一个参数是我们最重要的data struct,第二个参数是属性的类型,选择我们要得到的属性,第三个参数就是这个属性的值是多少,比如说电池电量是百分之多少。

这个函数是被挂在power_supply结构体中的get_property上的,它是在哪被回调呢?我们先在这里打个问号,我们知道这里只是在一些结构体中填充好了我们battery的信息,至于在什么时候回调,什么时候使用,什么时候上传uevent,我们后面会讲到,留意下!!

继续回到probe函数,下面是

[cpp]

data->battery.name = "battery";

data->battery.type = POWER_SUPPLY_TYPE_BATTERY;

名字和类型的填写。

下面就是跟硬件相关的东西了,一般的device是会用中断的方法去触发,这里goldfish的内核使用的是PC的中断资源。

[cpp]

data->irq = platform_get_irq(pdev, 0);

if (data->irq < 0) {

printk(KERN_ERR "%s: platform_get_irq failed\n", pdev->name);

ret = -ENODEV;

goto err_no_irq;

}

ret = request_irq(data->irq, goldfish_battery_interrupt, IRQF_SHARED, pdev->name, data);

得到中断好,然后申请中断,挂好中断触发的函数,这里发生中断后会做一系列的事情,我们也先放一下,先来看看下面的power_supply注册函数:

[cpp]

ret = power_supply_register(&pdev->dev, &data->ac);

if (ret)

goto err_ac_failed;

ret = power_supply_register(&pdev->dev, &data->battery);

if (ret)

goto err_battery_failed;

platform_set_drvdata(pdev, data);

battery_data = data;

power_supply_register函数在power_supply_core中被定义

[cpp]

int power_supply_register(struct device *parent, struct power_supply *psy)

{

int rc = 0;

psy->dev = device_create(power_supply_class, parent, 0, psy,

"%s", psy->name);

if (IS_ERR(psy->dev)) {

rc = PTR_ERR(psy->dev);

goto dev_create_failed;

}

INIT_WORK(&psy->changed_work, power_supply_changed_work);

rc = power_supply_create_attrs(psy);

if (rc)

goto create_attrs_failed;

rc = power_supply_create_triggers(psy);

if (rc)

goto create_triggers_failed;

power_supply_changed(psy);

goto success;

create_triggers_failed:

power_supply_remove_attrs(psy);

create_attrs_failed:

device_unregister(psy->dev);

dev_create_failed:

success:

return rc;

}

首先是时候device_create函数在class下创建设备驱动,传入的第一个参数就是我们的power_supply class

然后是初始化了工作队列INIT_WORK(&psy->changed_work, power_supply_changed_work);

oK,我们来看下这个工作队列的回调函数,power_supply_changed_work

[cpp]

static void power_supply_changed_work(struct work_struct *work)

{

struct power_supply *psy = container_of(work, struct power_supply,

changed_work);

dev_dbg(psy->dev, "%s\n", __func__);

class_for_each_device(power_supply_class, NULL, psy,

__power_supply_changed_work);

power_supply_update_leds(psy);

kobject_uevent(&psy->dev->kobj, KOBJ_CHANGE);

}

这里就是调用了2个函数,第一个 class_for_each_device(power_supply_class, NULL, psy,

__power_supply_changed_work);

它遍历了我们power_supply_class上的所有节点,用psy作为参数调用了__power_supply_changed_work函数,__power_supply_changed_work函数的作用是匹配我们的驱动

[cpp]

static int __power_supply_changed_work(struct device *dev, void *data)

{

struct power_supply *psy = (struct power_supply *)data;

struct power_supply *pst = dev_get_drvdata(dev);

int i;

for (i = 0; i < psy->num_supplicants; i++)

if (!strcmp(psy->supplied_to[i], pst->name)) {

if (pst->external_power_changed)

pst->external_power_changed(pst);

}

return 0;

}

之后再调用到了我们最最最最关键的地方kobject_uevent(&psy->dev->kobj, KOBJ_CHANGE);这里就是注册了kobject uevent事件,当我们的属性发生变化的时候会把uevent传给用户空间。

所以说,调用到我们的工作队列的时候就会向用户空间上报event,这个动作被封装在

[cpp]

void power_supply_changed(struct power_supply *psy)

{

dev_dbg(psy->dev, "%s\n", __func__);

schedule_work(&psy->changed_work);

}

之后会被使用到。

回到我们的power_supply_register函数中

rc = power_supply_create_attrs(psy);被定义在power_supply_sysfs.c中

[cpp]

int power_supply_create_attrs(struct power_supply *psy)

{

int rc = 0;

int i, j;

for (i = 0; i < ARRAY_SIZE(power_supply_static_attrs); i++) {

rc = device_create_file(psy->dev,

&power_supply_static_attrs[i]);

if (rc)

goto statics_failed;

}

for (j = 0; j < psy->num_properties; j++) {

rc = device_create_file(psy->dev,

&power_supply_attrs[psy->properties[j]]);

if (rc)

goto dynamics_failed;

}

goto succeed;

dynamics_failed:

while (j--)

device_remove_file(psy->dev,

&power_supply_attrs[psy->properties[j]]);

statics_failed:

while (i--)

device_remove_file(psy->dev, &power_supply_static_attrs[i]);

succeed:

return rc;

}

这边遍历了我们的属性数组,把每个属性在我们的驱动中声称文件系统,调用到device_create_flie函数,我们运行模拟器在power_supply/battery/下会发现我们填进去的属性值生成的所有文件。

这里介绍完毕,回到我们的goldfish驱动文件,最后就是我们的中断函数了。

[cpp]

static irqreturn_t goldfish_battery_interrupt(int irq, void *dev_id)

{

unsigned long irq_flags;

struct goldfish_battery_data *data = dev_id;

uint32_t status;

spin_lock_irqsave(&data->lock, irq_flags);

/* read status flags, which will clear the interrupt */

status = GOLDFISH_BATTERY_READ(data, BATTERY_INT_STATUS);

status &= BATTERY_INT_MASK;

if (status & BATTERY_STATUS_CHANGED)

power_supply_changed(&data->battery);

if (status & AC_STATUS_CHANGED)

power_supply_changed(&data->ac);

spin_unlock_irqrestore(&data->lock, irq_flags);

return status ? IRQ_HANDLED : IRQ_NONE;

}

这里我什么也不看只想看一句话

[cpp]

if (status & BATTERY_STATUS_CHANGED)

power_supply_changed(&data->battery);

if (status & AC_STATUS_CHANGED)

power_supply_changed(&data->ac);

之前讲过,就是power_supply_changed函数触发了向用户空间上报event事件的代码。OK ,android goldfish battery驱动就讲到这边,我看android模拟器的电池老是动啊动的很是不爽所以我在get_property函数中充电状态改成了不是充电状态,然后把电池电量设置为恒定的,嘿嘿,这样的话就不会动了,哈哈。下面贴张图,有图有真相

下面一篇我们会讲到android framework中jni对驱动的封装,好累啊,一口气写完battery driver分析。

摘自 zhangjie201412的专栏

赞助本站

人工智能实验室

相关热词: android开发 教程

相关内容
AiLab云推荐
展开

热门栏目HotCates

Copyright © 2010-2024 AiLab Team. 人工智能实验室 版权所有    关于我们 | 联系我们 | 广告服务 | 公司动态 | 免责声明 | 隐私条款 | 工作机会 | 展会港