Release 4.11 drivers/staging/greybus/power_supply.c
/*
* Power Supply driver for a Greybus module.
*
* Copyright 2014-2015 Google Inc.
* Copyright 2014-2015 Linaro Ltd.
*
* Released under the GPLv2 only.
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/power_supply.h>
#include <linux/slab.h>
#include "greybus.h"
#define PROP_MAX 32
struct gb_power_supply_prop {
enum power_supply_property prop;
u8 gb_prop;
int val;
int previous_val;
bool is_writeable;
};
struct gb_power_supply {
u8 id;
bool registered;
struct power_supply *psy;
struct power_supply_desc desc;
char name[64];
struct gb_power_supplies *supplies;
struct delayed_work work;
char *manufacturer;
char *model_name;
char *serial_number;
u8 type;
u8 properties_count;
u8 properties_count_str;
unsigned long last_update;
u8 cache_invalid;
unsigned int update_interval;
bool changed;
struct gb_power_supply_prop *props;
enum power_supply_property *props_raw;
bool pm_acquired;
struct mutex supply_lock;
};
struct gb_power_supplies {
struct gb_connection *connection;
u8 supplies_count;
struct gb_power_supply *supply;
struct mutex supplies_lock;
};
#define to_gb_power_supply(x) power_supply_get_drvdata(x)
/*
* General power supply properties that could be absent from various reasons,
* like kernel versions or vendor specific versions
*/
#ifndef POWER_SUPPLY_PROP_VOLTAGE_BOOT
#define POWER_SUPPLY_PROP_VOLTAGE_BOOT -1
#endif
#ifndef POWER_SUPPLY_PROP_CURRENT_BOOT
#define POWER_SUPPLY_PROP_CURRENT_BOOT -1
#endif
#ifndef POWER_SUPPLY_PROP_CALIBRATE
#define POWER_SUPPLY_PROP_CALIBRATE -1
#endif
/* cache time in milliseconds, if cache_time is set to 0 cache is disable */
static unsigned int cache_time = 1000;
/*
* update interval initial and maximum value, between the two will
* back-off exponential
*/
static unsigned int update_interval_init = 1 * HZ;
static unsigned int update_interval_max = 30 * HZ;
struct gb_power_supply_changes {
enum power_supply_property prop;
u32 tolerance_change;
void (*prop_changed)(struct gb_power_supply *gbpsy,
struct gb_power_supply_prop *prop);
};
static void gb_power_supply_state_change(struct gb_power_supply *gbpsy,
struct gb_power_supply_prop *prop);
static const struct gb_power_supply_changes psy_props_changes[] = {
{ .prop = GB_POWER_SUPPLY_PROP_STATUS,
.tolerance_change = 0,
.prop_changed = gb_power_supply_state_change,
},
{ .prop = GB_POWER_SUPPLY_PROP_TEMP,
.tolerance_change = 500,
.prop_changed = NULL,
},
{ .prop = GB_POWER_SUPPLY_PROP_ONLINE,
.tolerance_change = 0,
.prop_changed = NULL,
},
};
static int get_psp_from_gb_prop(int gb_prop, enum power_supply_property *psp)
{
int prop;
switch (gb_prop) {
case GB_POWER_SUPPLY_PROP_STATUS:
prop = POWER_SUPPLY_PROP_STATUS;
break;
case GB_POWER_SUPPLY_PROP_CHARGE_TYPE:
prop = POWER_SUPPLY_PROP_CHARGE_TYPE;
break;
case GB_POWER_SUPPLY_PROP_HEALTH:
prop = POWER_SUPPLY_PROP_HEALTH;
break;
case GB_POWER_SUPPLY_PROP_PRESENT:
prop = POWER_SUPPLY_PROP_PRESENT;
break;
case GB_POWER_SUPPLY_PROP_ONLINE:
prop = POWER_SUPPLY_PROP_ONLINE;
break;
case GB_POWER_SUPPLY_PROP_AUTHENTIC:
prop = POWER_SUPPLY_PROP_AUTHENTIC;
break;
case GB_POWER_SUPPLY_PROP_TECHNOLOGY:
prop = POWER_SUPPLY_PROP_TECHNOLOGY;
break;
case GB_POWER_SUPPLY_PROP_CYCLE_COUNT:
prop = POWER_SUPPLY_PROP_CYCLE_COUNT;
break;
case GB_POWER_SUPPLY_PROP_VOLTAGE_MAX:
prop = POWER_SUPPLY_PROP_VOLTAGE_MAX;
break;
case GB_POWER_SUPPLY_PROP_VOLTAGE_MIN:
prop = POWER_SUPPLY_PROP_VOLTAGE_MIN;
break;
case GB_POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
prop = POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN;
break;
case GB_POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
prop = POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN;
break;
case GB_POWER_SUPPLY_PROP_VOLTAGE_NOW:
prop = POWER_SUPPLY_PROP_VOLTAGE_NOW;
break;
case GB_POWER_SUPPLY_PROP_VOLTAGE_AVG:
prop = POWER_SUPPLY_PROP_VOLTAGE_AVG;
break;
case GB_POWER_SUPPLY_PROP_VOLTAGE_OCV:
prop = POWER_SUPPLY_PROP_VOLTAGE_OCV;
break;
case GB_POWER_SUPPLY_PROP_VOLTAGE_BOOT:
prop = POWER_SUPPLY_PROP_VOLTAGE_BOOT;
break;
case GB_POWER_SUPPLY_PROP_CURRENT_MAX:
prop = POWER_SUPPLY_PROP_CURRENT_MAX;
break;
case GB_POWER_SUPPLY_PROP_CURRENT_NOW:
prop = POWER_SUPPLY_PROP_CURRENT_NOW;
break;
case GB_POWER_SUPPLY_PROP_CURRENT_AVG:
prop = POWER_SUPPLY_PROP_CURRENT_AVG;
break;
case GB_POWER_SUPPLY_PROP_CURRENT_BOOT:
prop = POWER_SUPPLY_PROP_CURRENT_BOOT;
break;
case GB_POWER_SUPPLY_PROP_POWER_NOW:
prop = POWER_SUPPLY_PROP_POWER_NOW;
break;
case GB_POWER_SUPPLY_PROP_POWER_AVG:
prop = POWER_SUPPLY_PROP_POWER_AVG;
break;
case GB_POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
prop = POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN;
break;
case GB_POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN:
prop = POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN;
break;
case GB_POWER_SUPPLY_PROP_CHARGE_FULL:
prop = POWER_SUPPLY_PROP_CHARGE_FULL;
break;
case GB_POWER_SUPPLY_PROP_CHARGE_EMPTY:
prop = POWER_SUPPLY_PROP_CHARGE_EMPTY;
break;
case GB_POWER_SUPPLY_PROP_CHARGE_NOW:
prop = POWER_SUPPLY_PROP_CHARGE_NOW;
break;
case GB_POWER_SUPPLY_PROP_CHARGE_AVG:
prop = POWER_SUPPLY_PROP_CHARGE_AVG;
break;
case GB_POWER_SUPPLY_PROP_CHARGE_COUNTER:
prop = POWER_SUPPLY_PROP_CHARGE_COUNTER;
break;
case GB_POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
prop = POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT;
break;
case GB_POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
prop = POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX;
break;
case GB_POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
prop = POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE;
break;
case GB_POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
prop = POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX;
break;
case GB_POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT:
prop = POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT;
break;
case GB_POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX:
prop = POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX;
break;
case GB_POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
prop = POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT;
break;
case GB_POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
prop = POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN;
break;
case GB_POWER_SUPPLY_PROP_ENERGY_EMPTY_DESIGN:
prop = POWER_SUPPLY_PROP_ENERGY_EMPTY_DESIGN;
break;
case GB_POWER_SUPPLY_PROP_ENERGY_FULL:
prop = POWER_SUPPLY_PROP_ENERGY_FULL;
break;
case GB_POWER_SUPPLY_PROP_ENERGY_EMPTY:
prop = POWER_SUPPLY_PROP_ENERGY_EMPTY;
break;
case GB_POWER_SUPPLY_PROP_ENERGY_NOW:
prop = POWER_SUPPLY_PROP_ENERGY_NOW;
break;
case GB_POWER_SUPPLY_PROP_ENERGY_AVG:
prop = POWER_SUPPLY_PROP_ENERGY_AVG;
break;
case GB_POWER_SUPPLY_PROP_CAPACITY:
prop = POWER_SUPPLY_PROP_CAPACITY;
break;
case GB_POWER_SUPPLY_PROP_CAPACITY_ALERT_MIN:
prop = POWER_SUPPLY_PROP_CAPACITY_ALERT_MIN;
break;
case GB_POWER_SUPPLY_PROP_CAPACITY_ALERT_MAX:
prop = POWER_SUPPLY_PROP_CAPACITY_ALERT_MAX;
break;
case GB_POWER_SUPPLY_PROP_CAPACITY_LEVEL:
prop = POWER_SUPPLY_PROP_CAPACITY_LEVEL;
break;
case GB_POWER_SUPPLY_PROP_TEMP:
prop = POWER_SUPPLY_PROP_TEMP;
break;
case GB_POWER_SUPPLY_PROP_TEMP_MAX:
prop = POWER_SUPPLY_PROP_TEMP_MAX;
break;
case GB_POWER_SUPPLY_PROP_TEMP_MIN:
prop = POWER_SUPPLY_PROP_TEMP_MIN;
break;
case GB_POWER_SUPPLY_PROP_TEMP_ALERT_MIN:
prop = POWER_SUPPLY_PROP_TEMP_ALERT_MIN;
break;
case GB_POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
prop = POWER_SUPPLY_PROP_TEMP_ALERT_MAX;
break;
case GB_POWER_SUPPLY_PROP_TEMP_AMBIENT:
prop = POWER_SUPPLY_PROP_TEMP_AMBIENT;
break;
case GB_POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MIN:
prop = POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MIN;
break;
case GB_POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MAX:
prop = POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MAX;
break;
case GB_POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
prop = POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW;
break;
case GB_POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
prop = POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG;
break;
case GB_POWER_SUPPLY_PROP_TIME_TO_FULL_NOW:
prop = POWER_SUPPLY_PROP_TIME_TO_FULL_NOW;
break;
case GB_POWER_SUPPLY_PROP_TIME_TO_FULL_AVG:
prop = POWER_SUPPLY_PROP_TIME_TO_FULL_AVG;
break;
case GB_POWER_SUPPLY_PROP_TYPE:
prop = POWER_SUPPLY_PROP_TYPE;
break;
case GB_POWER_SUPPLY_PROP_SCOPE:
prop = POWER_SUPPLY_PROP_SCOPE;
break;
case GB_POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
prop = POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT;
break;
case GB_POWER_SUPPLY_PROP_CALIBRATE:
prop = POWER_SUPPLY_PROP_CALIBRATE;
break;
default:
prop = -1;
break;
}
if (prop < 0)
return prop;
*psp = (enum power_supply_property)prop;
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 547 | 100.00% | 2 | 100.00% |
| Total | 547 | 100.00% | 2 | 100.00% |
static struct gb_connection *get_conn_from_psy(struct gb_power_supply *gbpsy)
{
return gbpsy->supplies->connection;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 15 | 75.00% | 2 | 66.67% |
| Greg Kroah-Hartman | 5 | 25.00% | 1 | 33.33% |
| Total | 20 | 100.00% | 3 | 100.00% |
static struct gb_power_supply_prop *get_psy_prop(struct gb_power_supply *gbpsy,
enum power_supply_property psp)
{
int i;
for (i = 0; i < gbpsy->properties_count; i++)
if (gbpsy->props[i].prop == psp)
return &gbpsy->props[i];
return NULL;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 47 | 78.33% | 1 | 25.00% |
| Greg Kroah-Hartman | 13 | 21.67% | 3 | 75.00% |
| Total | 60 | 100.00% | 4 | 100.00% |
static int is_psy_prop_writeable(struct gb_power_supply *gbpsy,
enum power_supply_property psp)
{
struct gb_power_supply_prop *prop;
prop = get_psy_prop(gbpsy, psp);
if (!prop)
return -ENOENT;
return prop->is_writeable ? 1 : 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 28 | 59.57% | 2 | 50.00% |
| Greg Kroah-Hartman | 19 | 40.43% | 2 | 50.00% |
| Total | 47 | 100.00% | 4 | 100.00% |
static int is_prop_valint(enum power_supply_property psp)
{
return ((psp < POWER_SUPPLY_PROP_MODEL_NAME) ? 1 : 0);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 23 | 100.00% | 1 | 100.00% |
| Total | 23 | 100.00% | 1 | 100.00% |
static void next_interval(struct gb_power_supply *gbpsy)
{
if (gbpsy->update_interval == update_interval_max)
return;
/* do some exponential back-off in the update interval */
gbpsy->update_interval *= 2;
if (gbpsy->update_interval > update_interval_max)
gbpsy->update_interval = update_interval_max;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 41 | 100.00% | 1 | 100.00% |
| Total | 41 | 100.00% | 1 | 100.00% |
static void __gb_power_supply_changed(struct gb_power_supply *gbpsy)
{
power_supply_changed(gbpsy->psy);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 18 | 100.00% | 1 | 100.00% |
| Total | 18 | 100.00% | 1 | 100.00% |
static void gb_power_supply_state_change(struct gb_power_supply *gbpsy,
struct gb_power_supply_prop *prop)
{
struct gb_connection *connection = get_conn_from_psy(gbpsy);
int ret;
/*
* Check gbpsy->pm_acquired to make sure only one pair of 'get_sync'
* and 'put_autosuspend' runtime pm call for state property change.
*/
mutex_lock(&gbpsy->supply_lock);
if ((prop->val == GB_POWER_SUPPLY_STATUS_CHARGING) &&
!gbpsy->pm_acquired) {
ret = gb_pm_runtime_get_sync(connection->bundle);
if (ret)
dev_err(&connection->bundle->dev,
"Fail to set wake lock for charging state\n");
else
gbpsy->pm_acquired = true;
} else {
if (gbpsy->pm_acquired) {
ret = gb_pm_runtime_put_autosuspend(connection->bundle);
if (ret)
dev_err(&connection->bundle->dev,
"Fail to set wake unlock for none charging\n");
else
gbpsy->pm_acquired = false;
}
}
mutex_unlock(&gbpsy->supply_lock);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Philip Yang | 138 | 100.00% | 1 | 100.00% |
| Total | 138 | 100.00% | 1 | 100.00% |
static void check_changed(struct gb_power_supply *gbpsy,
struct gb_power_supply_prop *prop)
{
const struct gb_power_supply_changes *psyc;
int val = prop->val;
int prev_val = prop->previous_val;
bool changed = false;
int i;
for (i = 0; i < ARRAY_SIZE(psy_props_changes); i++) {
psyc = &psy_props_changes[i];
if (prop->prop == psyc->prop) {
if (!psyc->tolerance_change)
changed = true;
else if (val < prev_val &&
prev_val - val > psyc->tolerance_change)
changed = true;
else if (val > prev_val &&
val - prev_val > psyc->tolerance_change)
changed = true;
if (changed && psyc->prop_changed)
psyc->prop_changed(gbpsy, prop);
if (changed)
gbpsy->changed = true;
break;
}
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 159 | 100.00% | 3 | 100.00% |
| Total | 159 | 100.00% | 3 | 100.00% |
static int total_props(struct gb_power_supply *gbpsy)
{
/* this return the intval plus the strval properties */
return (gbpsy->properties_count + gbpsy->properties_count_str);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 23 | 100.00% | 1 | 100.00% |
| Total | 23 | 100.00% | 1 | 100.00% |
static void prop_append(struct gb_power_supply *gbpsy,
enum power_supply_property prop)
{
enum power_supply_property *new_props_raw;
gbpsy->properties_count_str++;
new_props_raw = krealloc(gbpsy->props_raw, total_props(gbpsy) *
sizeof(enum power_supply_property),
GFP_KERNEL);
if (!new_props_raw)
return;
gbpsy->props_raw = new_props_raw;
gbpsy->props_raw[total_props(gbpsy) - 1] = prop;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 73 | 100.00% | 1 | 100.00% |
| Total | 73 | 100.00% | 1 | 100.00% |
static int __gb_power_supply_set_name(char *init_name, char *name, size_t len)
{
unsigned int i = 0;
int ret = 0;
struct power_supply *psy;
if (!strlen(init_name))
init_name = "gb_power_supply";
strlcpy(name, init_name, len);
while ((ret < len) && (psy = power_supply_get_by_name(name))) {
power_supply_put(psy);
ret = snprintf(name, len, "%s_%u", init_name, ++i);
}
if (ret >= len)
return -ENOMEM;
return i;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 107 | 100.00% | 1 | 100.00% |
| Total | 107 | 100.00% | 1 | 100.00% |
static void _gb_power_supply_append_props(struct gb_power_supply *gbpsy)
{
if (strlen(gbpsy->manufacturer))
prop_append(gbpsy, POWER_SUPPLY_PROP_MANUFACTURER);
if (strlen(gbpsy->model_name))
prop_append(gbpsy, POWER_SUPPLY_PROP_MODEL_NAME);
if (strlen(gbpsy->serial_number))
prop_append(gbpsy, POWER_SUPPLY_PROP_SERIAL_NUMBER);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 59 | 100.00% | 1 | 100.00% |
| Total | 59 | 100.00% | 1 | 100.00% |
static int gb_power_supply_description_get(struct gb_power_supply *gbpsy)
{
struct gb_connection *connection = get_conn_from_psy(gbpsy);
struct gb_power_supply_get_description_request req;
struct gb_power_supply_get_description_response resp;
int ret;
req.psy_id = gbpsy->id;
ret = gb_operation_sync(connection,
GB_POWER_SUPPLY_TYPE_GET_DESCRIPTION,
&req, sizeof(req), &resp, sizeof(resp));
if (ret < 0)
return ret;
gbpsy->manufacturer = kstrndup(resp.manufacturer, PROP_MAX, GFP_KERNEL);
if (!gbpsy->manufacturer)
return -ENOMEM;
gbpsy->model_name = kstrndup(resp.model, PROP_MAX, GFP_KERNEL);
if (!gbpsy->model_name)
return -ENOMEM;
gbpsy->serial_number = kstrndup(resp.serial_number, PROP_MAX,
GFP_KERNEL);
if (!gbpsy->serial_number)
return -ENOMEM;
gbpsy->type = le16_to_cpu(resp.type);
gbpsy->properties_count = resp.properties_count;
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 174 | 100.00% | 1 | 100.00% |
| Total | 174 | 100.00% | 1 | 100.00% |
static int gb_power_supply_prop_descriptors_get(struct gb_power_supply *gbpsy)
{
struct gb_connection *connection = get_conn_from_psy(gbpsy);
struct gb_power_supply_get_property_descriptors_request *req;
struct gb_power_supply_get_property_descriptors_response *resp;
struct gb_operation *op;
u8 props_count = gbpsy->properties_count;
enum power_supply_property psp;
int ret;
int i, r = 0;
if (props_count == 0)
return 0;
op = gb_operation_create(connection,
GB_POWER_SUPPLY_TYPE_GET_PROP_DESCRIPTORS,
sizeof(req), sizeof(*resp) + props_count *
sizeof(struct gb_power_supply_props_desc),
GFP_KERNEL);
if (!op)
return -ENOMEM;
req = op->request->payload;
req->psy_id = gbpsy->id;
ret = gb_operation_request_send_sync(op);
if (ret < 0)
goto out_put_operation;
resp = op->response->payload;
/* validate received properties */
for (i = 0; i < props_count; i++) {
ret = get_psp_from_gb_prop(resp->props[i].property, &psp);
if (ret < 0) {
dev_warn(&connection->bundle->dev,
"greybus property %u it is not supported by this kernel, dropped\n",
resp->props[i].property);
gbpsy->properties_count--;
}
}
gbpsy->props = kcalloc(gbpsy->properties_count, sizeof(*gbpsy->props),
GFP_KERNEL);
if (!gbpsy->props) {
ret = -ENOMEM;
goto out_put_operation;
}
gbpsy->props_raw = kcalloc(gbpsy->properties_count,
sizeof(*gbpsy->props_raw), GFP_KERNEL);
if (!gbpsy->props_raw) {
ret = -ENOMEM;
goto out_put_operation;
}
/* Store available properties, skip the ones we do not support */
for (i = 0; i < props_count; i++) {
ret = get_psp_from_gb_prop(resp->props[i].property, &psp);
if (ret < 0) {
r++;
continue;
}
gbpsy->props[i - r].prop = psp;
gbpsy->props[i - r].gb_prop = resp->props[i].property;
gbpsy->props_raw[i - r] = psp;
if (resp->props[i].is_writeable)
gbpsy->props[i - r].is_writeable = true;
}
/*
* now append the properties that we already got information in the
* get_description operation. (char * ones)
*/
_gb_power_supply_append_props(gbpsy);
ret = 0;
out_put_operation:
gb_operation_put(op);
return ret;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 421 | 100.00% | 3 | 100.00% |
| Total | 421 | 100.00% | 3 | 100.00% |
static int __gb_power_supply_property_update(struct gb_power_supply *gbpsy,
enum power_supply_property psp)
{
struct gb_connection *connection = get_conn_from_psy(gbpsy);
struct gb_power_supply_prop *prop;
struct gb_power_supply_get_property_request req;
struct gb_power_supply_get_property_response resp;
int val;
int ret;
prop = get_psy_prop(gbpsy, psp);
if (!prop)
return -EINVAL;
req.psy_id = gbpsy->id;
req.property = prop->gb_prop;
ret = gb_operation_sync(connection, GB_POWER_SUPPLY_TYPE_GET_PROPERTY,
&req, sizeof(req), &resp, sizeof(resp));
if (ret < 0)
return ret;
val = le32_to_cpu(resp.prop_val);
if (val == prop->val)
return 0;
prop->previous_val = prop->val;
prop->val = val;
check_changed(gbpsy, prop);
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 156 | 100.00% | 3 | 100.00% |
| Total | 156 | 100.00% | 3 | 100.00% |
static int __gb_power_supply_property_get(struct gb_power_supply *gbpsy,
enum power_supply_property psp,
union power_supply_propval *val)
{
struct gb_power_supply_prop *prop;
prop = get_psy_prop(gbpsy, psp);
if (!prop)
return -EINVAL;
val->intval = prop->val;
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 54 | 100.00% | 1 | 100.00% |
| Total | 54 | 100.00% | 1 | 100.00% |
static int __gb_power_supply_property_strval_get(struct gb_power_supply *gbpsy,
enum power_supply_property psp,
union power_supply_propval *val)
{
switch (psp) {
case POWER_SUPPLY_PROP_MODEL_NAME:
val->strval = gbpsy->model_name;
break;
case POWER_SUPPLY_PROP_MANUFACTURER:
val->strval = gbpsy->manufacturer;
break;
case POWER_SUPPLY_PROP_SERIAL_NUMBER:
val->strval = gbpsy->serial_number;
break;
default:
break;
}
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 67 | 100.00% | 1 | 100.00% |
| Total | 67 | 100.00% | 1 | 100.00% |
static int _gb_power_supply_property_get(struct gb_power_supply *gbpsy,
enum power_supply_property psp,
union power_supply_propval *val)
{
struct gb_connection *connection = get_conn_from_psy(gbpsy);
int ret;
/*
* Properties of type const char *, were already fetched on
* get_description operation and should be cached in gb
*/
if (is_prop_valint(psp))
ret = __gb_power_supply_property_get(gbpsy, psp, val);
else
ret = __gb_power_supply_property_strval_get(gbpsy, psp, val);
if (ret < 0)
dev_err(&connection->bundle->dev, "get property %u\n", psp);
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 87 | 100.00% | 1 | 100.00% |
| Total | 87 | 100.00% | 1 | 100.00% |
static int is_cache_valid(struct gb_power_supply *gbpsy)
{
/* check if cache is good enough or it has expired */
if (gbpsy->cache_invalid) {
gbpsy->cache_invalid = 0;
return 0;
}
if (gbpsy->last_update &&
time_is_after_jiffies(gbpsy->last_update +
msecs_to_jiffies(cache_time)))
return 1;
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 53 | 100.00% | 2 | 100.00% |
| Total | 53 | 100.00% | 2 | 100.00% |
static int gb_power_supply_status_get(struct gb_power_supply *gbpsy)
{
struct gb_connection *connection = get_conn_from_psy(gbpsy);
int ret = 0;
int i;
if (is_cache_valid(gbpsy))
return 0;
ret = gb_pm_runtime_get_sync(connection->bundle);
if (ret)
return ret;
for (i = 0; i < gbpsy->properties_count; i++) {
ret = __gb_power_supply_property_update(gbpsy,
gbpsy->props[i].prop);
if (ret < 0)
break;
}
if (ret == 0)
gbpsy->last_update = jiffies;
gb_pm_runtime_put_autosuspend(connection->bundle);
return ret;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 84 | 71.79% | 2 | 66.67% |
| Philip Yang | 33 | 28.21% | 1 | 33.33% |
| Total | 117 | 100.00% | 3 | 100.00% |
static void gb_power_supply_status_update(struct gb_power_supply *gbpsy)
{
/* check if there a change that need to be reported */
gb_power_supply_status_get(gbpsy);
if (!gbpsy->changed)
return;
gbpsy->update_interval = update_interval_init;
__gb_power_supply_changed(gbpsy);
gbpsy->changed = false;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 42 | 100.00% | 1 | 100.00% |
| Total | 42 | 100.00% | 1 | 100.00% |
static void gb_power_supply_work(struct work_struct *work)
{
struct gb_power_supply *gbpsy = container_of(work,
struct gb_power_supply,
work.work);
/*
* if the poll interval is not set, disable polling, this is helpful
* specially at unregister time.
*/
if (!gbpsy->update_interval)
return;
gb_power_supply_status_update(gbpsy);
next_interval(gbpsy);
schedule_delayed_work(&gbpsy->work, gbpsy->update_interval);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 59 | 100.00% | 1 | 100.00% |
| Total | 59 | 100.00% | 1 | 100.00% |
static int get_property(struct power_supply *b,
enum power_supply_property psp,
union power_supply_propval *val)
{
struct gb_power_supply *gbpsy = to_gb_power_supply(b);
gb_power_supply_status_get(gbpsy);
return _gb_power_supply_property_get(gbpsy, psp, val);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 45 | 100.00% | 1 | 100.00% |
| Total | 45 | 100.00% | 1 | 100.00% |
static int gb_power_supply_property_set(struct gb_power_supply *gbpsy,
enum power_supply_property psp,
int val)
{
struct gb_connection *connection = get_conn_from_psy(gbpsy);
struct gb_power_supply_prop *prop;
struct gb_power_supply_set_property_request req;
int ret;
ret = gb_pm_runtime_get_sync(connection->bundle);
if (ret)
return ret;
prop = get_psy_prop(gbpsy, psp);
if (!prop) {
ret = -EINVAL;
goto out;
}
req.psy_id = gbpsy->id;
req.property = prop->gb_prop;
req.prop_val = cpu_to_le32((s32)val);
ret = gb_operation_sync(connection, GB_POWER_SUPPLY_TYPE_SET_PROPERTY,
&req, sizeof(req), NULL, 0);
if (ret < 0)
goto out;
/* cache immediately the new value */
prop->val = val;
out:
gb_pm_runtime_put_autosuspend(connection->bundle);
return ret;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 125 | 79.62% | 3 | 60.00% |
| Philip Yang | 31 | 19.75% | 1 | 20.00% |
| Greg Kroah-Hartman | 1 | 0.64% | 1 | 20.00% |
| Total | 157 | 100.00% | 5 | 100.00% |
static int set_property(struct power_supply *b,
enum power_supply_property psp,
const union power_supply_propval *val)
{
struct gb_power_supply *gbpsy = to_gb_power_supply(b);
return gb_power_supply_property_set(gbpsy, psp, val->intval);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 43 | 100.00% | 1 | 100.00% |
| Total | 43 | 100.00% | 1 | 100.00% |
static int property_is_writeable(struct power_supply *b,
enum power_supply_property psp)
{
struct gb_power_supply *gbpsy = to_gb_power_supply(b);
return is_psy_prop_writeable(gbpsy, psp);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 33 | 100.00% | 1 | 100.00% |
| Total | 33 | 100.00% | 1 | 100.00% |
static int gb_power_supply_register(struct gb_power_supply *gbpsy)
{
struct gb_connection *connection = get_conn_from_psy(gbpsy);
struct power_supply_config cfg = {};
cfg.drv_data = gbpsy;
gbpsy->desc.name = gbpsy->name;
gbpsy->desc.type = gbpsy->type;
gbpsy->desc.properties = gbpsy->props_raw;
gbpsy->desc.num_properties = total_props(gbpsy);
gbpsy->desc.get_property = get_property;
gbpsy->desc.set_property = set_property;
gbpsy->desc.property_is_writeable = property_is_writeable;
gbpsy->psy = power_supply_register(&connection->bundle->dev,
&gbpsy->desc, &cfg);
return PTR_ERR_OR_ZERO(gbpsy->psy);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 104 | 81.25% | 2 | 33.33% |
| Greg Kroah-Hartman | 23 | 17.97% | 3 | 50.00% |
| Alex Elder | 1 | 0.78% | 1 | 16.67% |
| Total | 128 | 100.00% | 6 | 100.00% |
static void _gb_power_supply_free(struct gb_power_supply *gbpsy)
{
kfree(gbpsy->serial_number);
kfree(gbpsy->model_name);
kfree(gbpsy->manufacturer);
kfree(gbpsy->props_raw);
kfree(gbpsy->props);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 36 | 78.26% | 2 | 40.00% |
| Greg Kroah-Hartman | 10 | 21.74% | 3 | 60.00% |
| Total | 46 | 100.00% | 5 | 100.00% |
static void _gb_power_supply_release(struct gb_power_supply *gbpsy)
{
gbpsy->update_interval = 0;
cancel_delayed_work_sync(&gbpsy->work);
if (gbpsy->registered)
power_supply_unregister(gbpsy->psy);
_gb_power_supply_free(gbpsy);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 38 | 88.37% | 2 | 50.00% |
| Greg Kroah-Hartman | 5 | 11.63% | 2 | 50.00% |
| Total | 43 | 100.00% | 4 | 100.00% |
static void _gb_power_supplies_release(struct gb_power_supplies *supplies)
{
int i;
if (!supplies->supply)
return;
mutex_lock(&supplies->supplies_lock);
for (i = 0; i < supplies->supplies_count; i++)
_gb_power_supply_release(&supplies->supply[i]);
kfree(supplies->supply);
mutex_unlock(&supplies->supplies_lock);
kfree(supplies);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 58 | 76.32% | 4 | 57.14% |
| Greg Kroah-Hartman | 18 | 23.68% | 3 | 42.86% |
| Total | 76 | 100.00% | 7 | 100.00% |
static int gb_power_supplies_get_count(struct gb_power_supplies *supplies)
{
struct gb_power_supply_get_supplies_response resp;
int ret;
ret = gb_operation_sync(supplies->connection,
GB_POWER_SUPPLY_TYPE_GET_SUPPLIES,
NULL, 0, &resp, sizeof(resp));
if (ret < 0)
return ret;
if (!resp.supplies_count)
return -EINVAL;
supplies->supplies_count = resp.supplies_count;
return ret;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Greg Kroah-Hartman | 40 | 55.56% | 3 | 75.00% |
| Rui Miguel Silva | 32 | 44.44% | 1 | 25.00% |
| Total | 72 | 100.00% | 4 | 100.00% |
static int gb_power_supply_config(struct gb_power_supplies *supplies, int id)
{
struct gb_power_supply *gbpsy = &supplies->supply[id];
int ret;
gbpsy->supplies = supplies;
gbpsy->id = id;
ret = gb_power_supply_description_get(gbpsy);
if (ret < 0)
return ret;
return gb_power_supply_prop_descriptors_get(gbpsy);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 38 | 59.38% | 3 | 50.00% |
| Greg Kroah-Hartman | 22 | 34.38% | 2 | 33.33% |
| Viresh Kumar | 4 | 6.25% | 1 | 16.67% |
| Total | 64 | 100.00% | 6 | 100.00% |
static int gb_power_supply_enable(struct gb_power_supply *gbpsy)
{
int ret;
/* guarantee that we have an unique name, before register */
ret = __gb_power_supply_set_name(gbpsy->model_name, gbpsy->name,
sizeof(gbpsy->name));
if (ret < 0)
return ret;
mutex_init(&gbpsy->supply_lock);
ret = gb_power_supply_register(gbpsy);
if (ret < 0)
return ret;
gbpsy->update_interval = update_interval_init;
INIT_DELAYED_WORK(&gbpsy->work, gb_power_supply_work);
schedule_delayed_work(&gbpsy->work, 0);
/* everything went fine, mark it for release code to know */
gbpsy->registered = true;
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 75 | 72.12% | 3 | 42.86% |
| Greg Kroah-Hartman | 14 | 13.46% | 1 | 14.29% |
| Philip Yang | 8 | 7.69% | 1 | 14.29% |
| Viresh Kumar | 6 | 5.77% | 1 | 14.29% |
| Perry Hung | 1 | 0.96% | 1 | 14.29% |
| Total | 104 | 100.00% | 7 | 100.00% |
static int gb_power_supplies_setup(struct gb_power_supplies *supplies)
{
struct gb_connection *connection = supplies->connection;
int ret;
int i;
mutex_lock(&supplies->supplies_lock);
ret = gb_power_supplies_get_count(supplies);
if (ret < 0)
goto out;
supplies->supply = kzalloc(supplies->supplies_count *
sizeof(struct gb_power_supply),
GFP_KERNEL);
if (!supplies->supply) {
ret = -ENOMEM;
goto out;
}
for (i = 0; i < supplies->supplies_count; i++) {
ret = gb_power_supply_config(supplies, i);
if (ret < 0) {
dev_err(&connection->bundle->dev,
"Fail to configure supplies devices\n");
goto out;
}
}
out:
mutex_unlock(&supplies->supplies_lock);
return ret;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 107 | 72.30% | 1 | 12.50% |
| Greg Kroah-Hartman | 30 | 20.27% | 4 | 50.00% |
| Johan Hovold | 8 | 5.41% | 1 | 12.50% |
| Alex Elder | 3 | 2.03% | 2 | 25.00% |
| Total | 148 | 100.00% | 8 | 100.00% |
static int gb_power_supplies_register(struct gb_power_supplies *supplies)
{
struct gb_connection *connection = supplies->connection;
int ret = 0;
int i;
mutex_lock(&supplies->supplies_lock);
for (i = 0; i < supplies->supplies_count; i++) {
ret = gb_power_supply_enable(&supplies->supply[i]);
if (ret < 0) {
dev_err(&connection->bundle->dev,
"Fail to enable supplies devices\n");
break;
}
}
mutex_unlock(&supplies->supplies_lock);
return ret;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Viresh Kumar | 98 | 100.00% | 1 | 100.00% |
| Total | 98 | 100.00% | 1 | 100.00% |
static int gb_supplies_request_handler(struct gb_operation *op)
{
struct gb_connection *connection = op->connection;
struct gb_power_supplies *supplies = gb_connection_get_data(connection);
struct gb_power_supply *gbpsy;
struct gb_message *request;
struct gb_power_supply_event_request *payload;
u8 psy_id;
u8 event;
int ret = 0;
if (op->type != GB_POWER_SUPPLY_TYPE_EVENT) {
dev_err(&connection->bundle->dev,
"Unsupported unsolicited event: %u\n", op->type);
return -EINVAL;
}
request = op->request;
if (request->payload_size < sizeof(*payload)) {
dev_err(&connection->bundle->dev,
"Wrong event size received (%zu < %zu)\n",
request->payload_size, sizeof(*payload));
return -EINVAL;
}
payload = request->payload;
psy_id = payload->psy_id;
mutex_lock(&supplies->supplies_lock);
if (psy_id >= supplies->supplies_count ||
!supplies->supply[psy_id].registered) {
dev_err(&connection->bundle->dev,
"Event received for unconfigured power_supply id: %d\n",
psy_id);
ret = -EINVAL;
goto out_unlock;
}
event = payload->event;
/*
* we will only handle events after setup is done and before release is
* running. For that just check update_interval.
*/
gbpsy = &supplies->supply[psy_id];
if (!gbpsy->update_interval) {
ret = -ESHUTDOWN;
goto out_unlock;
}
if (event & GB_POWER_SUPPLY_UPDATE) {
/*
* we need to make sure we invalidate cache, if not no new
* values for the properties will be fetch and the all propose
* of this event is missed
*/
gbpsy->cache_invalid = 1;
gb_power_supply_status_update(gbpsy);
}
out_unlock:
mutex_unlock(&supplies->supplies_lock);
return ret;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 206 | 78.93% | 5 | 45.45% |
| Greg Kroah-Hartman | 50 | 19.16% | 5 | 45.45% |
| Viresh Kumar | 5 | 1.92% | 1 | 9.09% |
| Total | 261 | 100.00% | 11 | 100.00% |
static int gb_power_supply_probe(struct gb_bundle *bundle,
const struct greybus_bundle_id *id)
{
struct greybus_descriptor_cport *cport_desc;
struct gb_connection *connection;
struct gb_power_supplies *supplies;
int ret;
if (bundle->num_cports != 1)
return -ENODEV;
cport_desc = &bundle->cport_desc[0];
if (cport_desc->protocol_id != GREYBUS_PROTOCOL_POWER_SUPPLY)
return -ENODEV;
supplies = kzalloc(sizeof(*supplies), GFP_KERNEL);
if (!supplies)
return -ENOMEM;
connection = gb_connection_create(bundle, le16_to_cpu(cport_desc->id),
gb_supplies_request_handler);
if (IS_ERR(connection)) {
ret = PTR_ERR(connection);
goto out;
}
supplies->connection = connection;
gb_connection_set_data(connection, supplies);
mutex_init(&supplies->supplies_lock);
greybus_set_drvdata(bundle, supplies);
/* We aren't ready to receive an incoming request yet */
ret = gb_connection_enable_tx(connection);
if (ret)
goto error_connection_destroy;
ret = gb_power_supplies_setup(supplies);
if (ret < 0)
goto error_connection_disable;
/* We are ready to receive an incoming request now, enable RX as well */
ret = gb_connection_enable(connection);
if (ret)
goto error_connection_disable;
ret = gb_power_supplies_register(supplies);
if (ret < 0)
goto error_connection_disable;
gb_pm_runtime_put_autosuspend(bundle);
return 0;
error_connection_disable:
gb_connection_disable(connection);
error_connection_destroy:
gb_connection_destroy(connection);
out:
_gb_power_supplies_release(supplies);
return ret;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Viresh Kumar | 163 | 65.73% | 2 | 25.00% |
| Greg Kroah-Hartman | 47 | 18.95% | 3 | 37.50% |
| Rui Miguel Silva | 33 | 13.31% | 2 | 25.00% |
| Philip Yang | 5 | 2.02% | 1 | 12.50% |
| Total | 248 | 100.00% | 8 | 100.00% |
static void gb_power_supply_disconnect(struct gb_bundle *bundle)
{
struct gb_power_supplies *supplies = greybus_get_drvdata(bundle);
gb_connection_disable(supplies->connection);
gb_connection_destroy(supplies->connection);
_gb_power_supplies_release(supplies);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Viresh Kumar | 20 | 50.00% | 1 | 25.00% |
| Alex Elder | 16 | 40.00% | 2 | 50.00% |
| Rui Miguel Silva | 4 | 10.00% | 1 | 25.00% |
| Total | 40 | 100.00% | 4 | 100.00% |
static const struct greybus_bundle_id gb_power_supply_id_table[] = {
{ GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_POWER_SUPPLY) },
{ }
};
MODULE_DEVICE_TABLE(greybus, gb_power_supply_id_table);
static struct greybus_driver gb_power_supply_driver = {
.name = "power_supply",
.probe = gb_power_supply_probe,
.disconnect = gb_power_supply_disconnect,
.id_table = gb_power_supply_id_table,
};
module_greybus_driver(gb_power_supply_driver);
MODULE_LICENSE("GPL v2");
Overall Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Rui Miguel Silva | 3577 | 78.98% | 16 | 43.24% |
| Greg Kroah-Hartman | 336 | 7.42% | 10 | 27.03% |
| Viresh Kumar | 331 | 7.31% | 2 | 5.41% |
| Philip Yang | 238 | 5.26% | 1 | 2.70% |
| Alex Elder | 38 | 0.84% | 6 | 16.22% |
| Johan Hovold | 8 | 0.18% | 1 | 2.70% |
| Perry Hung | 1 | 0.02% | 1 | 2.70% |
| Total | 4529 | 100.00% | 37 | 100.00% |
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.