static gboolean modem_changed(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
struct modem_data *modem;
DBusMessageIter iter, value;
const char *path, *key;
if (dbus_message_iter_init(msg, &iter) == FALSE)
return TRUE;
path = dbus_message_get_path(msg);
modem = g_hash_table_lookup(modem_list, path);
if (modem == NULL)
return TRUE;
dbus_message_iter_get_basic(&iter, &key);
dbus_message_iter_next(&iter);
dbus_message_iter_recurse(&iter, &value);
if (g_str_equal(key, "Interfaces") == TRUE)
check_interfaces(modem, &value);
else if (g_str_equal(key, "Manufacturer") == TRUE)
check_manufacturer(modem, &value);
return TRUE;
}
static void create_modem(DBusConnection *conn,
const char *path, DBusMessageIter *iter)
{
struct modem_data *modem;
DBusMessageIter dict;
modem = g_try_new0(struct modem_data, 1);
if (modem == NULL)
return;
modem->path = g_strdup(path);
modem->format = AFMT_S16_LE;
modem->channels = 1;
modem->speed = 8000;
modem->dsp_out = -1;
modem->call_list = g_hash_table_new_full(g_str_hash, g_str_equal,
NULL, destroy_call);
modem->conn = conn;
modem->call_added_watch = g_dbus_add_signal_watch(conn, NULL,
modem->path, OFONO_CALLMANAGER_INTERFACE,
"CallAdded", call_added, modem, NULL);
modem->call_removed_watch = g_dbus_add_signal_watch(conn, NULL,
modem->path, OFONO_CALLMANAGER_INTERFACE,
"CallRemoved", call_removed, modem, NULL);
modem->call_changed_watch = g_dbus_add_signal_watch(conn, NULL,
NULL, OFONO_CALL_INTERFACE,
"PropertyChanged", call_changed, modem, NULL);
modem->audio_changed_watch = g_dbus_add_signal_watch(conn, NULL,
NULL, OFONO_AUDIO_INTERFACE,
"PropertyChanged", audio_changed, modem, NULL);
g_hash_table_replace(modem_list, modem->path, modem);
g_print("modem added (%s)\n", modem->path);
dbus_message_iter_recurse(iter, &dict);
while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
DBusMessageIter entry, value;
const char *key;
dbus_message_iter_recurse(&dict, &entry);
dbus_message_iter_get_basic(&entry, &key);
dbus_message_iter_next(&entry);
dbus_message_iter_recurse(&entry, &value);
if (g_str_equal(key, "Interfaces") == TRUE)
check_interfaces(modem, &value);
else if (g_str_equal(key, "Manufacturer") == TRUE)
check_manufacturer(modem, &value);
dbus_message_iter_next(&dict);
}
}
static int __devinit bq27541_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
struct bq27541_info *di;
int ret;
int error;
printk(KERN_INFO "%s\n",__func__);
di = kzalloc(sizeof(*di), GFP_KERNEL);
if (!di) {
return -ENOMEM;
}
di->bat_client = client;
di->dev = &client->dev;
di->bat.type = POWER_SUPPLY_TYPE_BATTERY;
di->bat.name = "battery";
di->bat.properties = bq27x00_battery_props;
di->bat.num_properties = ARRAY_SIZE(bq27x00_battery_props);
di->bat.get_property = bq27x00_get_property;
di->bat.external_power_changed = NULL;
di->temp = 0;
di->ntc_temp = 0;
di->voltage = 0;
di->current_avg = 0;
di->capacity = 0;
di->status = 0;
di->sec = 0;
/*Manufacturer id check function */
di->manufacturer = UNKNOW;
di->battery_polling = 1;fake_temp=-990;fake_full_available_capacity=0;
di->disable_led=0;
di->health = POWER_SUPPLY_HEALTH_GOOD;
i2c_set_clientdata(client, di);
ret = power_supply_register(di->dev, &di->bat);
if (ret) {
dev_dbg(di->dev,"failed to register battery\n");
//goto bk_batt_failed;
}
/*Manufacturer id check function */
di->manufacturer=check_manufacturer(di);
bq27x00_read(REG_FULL_AVAILABLE_CHARGE, &g_full_available_capacity, 0, di);
create_bq_procfs(di);
#ifdef BAT_LOG
INIT_DELAYED_WORK_DEFERRABLE(&di->bat_log_work,bat_log_work_func);
#endif
INIT_DELAYED_WORK_DEFERRABLE(&di->bat_monitor_work,bat_monitor_work_func);
queue_delayed_work(bat_work_queue,&di->bat_monitor_work,
msecs_to_jiffies(1000 * 1));
BLOCKING_INIT_NOTIFIER_HEAD(¬ifier_list);
/* Create a sysfs node */
error = sysfs_create_group(&di->dev->kobj, &bq_attr_grp);
if (error) {
dev_dbg(di->dev,"could not create sysfs_create_group\n");
return -1;
}
return 0;
}
static struct sr_dev_inst *hmo_probe_serial_device(struct sr_scpi_dev_inst *scpi)
{
struct sr_dev_inst *sdi;
struct dev_context *devc;
struct sr_scpi_hw_info *hw_info;
sdi = NULL;
devc = NULL;
hw_info = NULL;
if (sr_scpi_get_hw_id(scpi, &hw_info) != SR_OK) {
sr_info("Couldn't get IDN response.");
goto fail;
}
if (check_manufacturer(hw_info->manufacturer) != SR_OK)
goto fail;
sdi = g_malloc0(sizeof(struct sr_dev_inst));
sdi->status = SR_ST_ACTIVE;
sdi->vendor = g_strdup(hw_info->manufacturer);
sdi->model = g_strdup(hw_info->model);
sdi->version = g_strdup(hw_info->firmware_version);
sdi->serial_num = g_strdup(hw_info->serial_number);
sdi->driver = &hameg_hmo_driver_info;
sdi->inst_type = SR_INST_SCPI;
sdi->conn = scpi;
sr_scpi_hw_info_free(hw_info);
hw_info = NULL;
devc = g_malloc0(sizeof(struct dev_context));
sdi->priv = devc;
if (hmo_init_device(sdi) != SR_OK)
goto fail;
sr_scpi_close(sdi->conn);
sdi->status = SR_ST_INACTIVE;
return sdi;
fail:
if (hw_info)
sr_scpi_hw_info_free(hw_info);
if (sdi)
sr_dev_inst_free(sdi);
g_free(devc);
return NULL;
}
void bat_monitor_work_func(struct work_struct *work)
{
struct bq27541_info *di = container_of(work,
struct bq27541_info, bat_monitor_work.work);
int err = 0;
int new_value=0;
int change=0;
//For dead battery
if(di->err_count>=15){
printk("bat:%s get i2c error\n",__func__);
err=bq27x00_battery_voltage(di,&new_value);
if (err){
queue_delayed_work(bat_work_queue,&di->bat_monitor_work,
msecs_to_jiffies(10000 * 1));
blocking_notifier_call_chain(¬ifier_list, EVENT_BATTERY_I2C_ERROR, NULL);
di->health = POWER_SUPPLY_HEALTH_UNKNOWN;
power_supply_changed(&di->bat);
}else{//dead battery is wake up
printk("bat:%s dead battery is wake up\n",__func__);
di->err_count=0;
queue_delayed_work(bat_work_queue,&di->bat_monitor_work,0);
blocking_notifier_call_chain(¬ifier_list, EVENT_BATTERY_I2C_NORMAL, NULL);
di->health = POWER_SUPPLY_HEALTH_GOOD;
power_supply_changed(&di->bat);
}
}else{
/*
* We query the four most important variables frequently:
*
* temperature, voltage, capacity, status
*
* These four are used by various code in upper layers for
* power management. The rest of the variables are not that
* important or do not change much over time so we do not
* need to query them too often
*/
if (bq27x00_battery_temperature(di, &new_value)) {
di->err_count++;
} else {
if (new_value != di->temp) {
di->temp = new_value;
change = 1;
bat_temp_charge_protect(di);
}
}
if (bq27x00_battery_voltage(di, &new_value)) {
di->err_count++;
} else {
if (new_value != di->voltage) {
di->voltage = new_value;
change = 1;
//Low battery protection
//If android with weak battery has some problem and not be shutdown then driver need to turn off the system.
if((di->voltage <= HARD_LOW_VOLTAGE_THRESHOLD)
&& (di->status==POWER_SUPPLY_STATUS_DISCHARGING))
blocking_notifier_call_chain(¬ifier_list, EVENT_WEAK_BATTERY, NULL);
}
}
if (bq27x00_battery_rsoc(di, &new_value)) {
di->err_count++;
} else {
if (new_value != di->capacity) {
di->capacity = new_value;
change = 1;
//Recharge event
if((di->status==POWER_SUPPLY_STATUS_NOT_CHARGING)
&& (di->capacity<=RECHARGE_THRESHOLD))
blocking_notifier_call_chain(¬ifier_list, EVENT_RECHARGE_BATTERY, NULL);
}
}
if (bq27x00_battery_status(di, &new_value)) {
di->err_count++;
} else {
if (new_value!=di->status) {
di->status = new_value;
change = 1;
//Full charge protectition event
if (di->status == POWER_SUPPLY_STATUS_FULL)
blocking_notifier_call_chain(¬ifier_list, EVENT_FULL_BATTERY, NULL);
}
}
/*
* Average current is also required to be
* queried frequently for factory testing
*/
if (bq27x00_battery_current(di, &new_value)){
di->err_count++;
} else {
if (new_value != di->current_avg) {
di->current_avg=new_value;
change = 1;
}
}
if (++di->long_count != BQ27541_LONG_COUNT) {
/* Done with the important ones, skip the rest for now */
goto update_status;
} else {
di->long_count = 0;
}
new_value=twl_get_batntc();
if(new_value!=di->ntc_temp){
if((di->ntc_temp==0) && (new_value>0))
blocking_notifier_call_chain(¬ifier_list, EVENT_BATTERY_NTC_NORMAL, NULL);
di->ntc_temp=new_value;
if(di->ntc_temp==0)
blocking_notifier_call_chain(¬ifier_list, EVENT_BATTERY_NTC_ZERO, NULL);
}
bq27x00_read(REG_FULL_AVAILABLE_CHARGE, &g_full_available_capacity, 0, di);
if (bq27x00_battery_health(di, &new_value)) {
di->err_count++;
} else {
if (new_value != di->health) {
di->health = new_value;
change = 1;
}
}
/* Query TimeToEmpty() register */
if (bq27x00_battery_time_to_empty(di, &new_value)) {
di->err_count++;
} else if (new_value != di->time_to_empty) {
di->time_to_empty = new_value;
change = 1;
}
/* Query TimeToFull() register */
if (bq27x00_battery_time_to_full(di, &new_value)) {
di->err_count++;
} else if (new_value != di->time_to_full) {
di->time_to_full = new_value;
change = 1;
}
/* Query CycleCount() register */
if (bq27x00_battery_cycle_count(di, &new_value)) {
di->err_count++;
} else if (new_value != di->cycle_count) {
di->cycle_count = new_value;
change = 1;
}
/* Query AveragePower() register */
if (bq27x00_battery_average_power(di, &new_value)) {
di->err_count++;
} else if (new_value != di->average_power) {
di->average_power = new_value;
change = 1;
}
/* Query AvailableEnergy() register */
if (bq27x00_battery_available_energy(di, &new_value)) {
di->err_count++;
} else if (new_value != di->available_energy) {
di->available_energy = new_value;
change = 1;
}
/* Query RemainingCapacity() register */
if (bq27x00_battery_remaining_charge(di, &new_value)) {
di->err_count++;
} else if (new_value != di->remaining_charge) {
di->remaining_charge = new_value;
change = 1;
}
/* Query FullChargeCapacity() register */
if (bq27x00_battery_full_charge(di, &new_value)) {
di->err_count++;
} else if (new_value != di->full_charge) {
di->full_charge = new_value;
change = 1;
}
/* Query FullAvailableCapacity() register */
if (bq27x00_battery_full_charge_uncompensated(di, &new_value)) {
di->err_count++;
} else if (new_value != di->full_charge_uncompensated) {
di->full_charge_uncompensated = new_value;
change = 1;
}
if (++di->manufacturer_id_read_count != 2) {
goto update_status;
} else {
di->manufacturer_id_read_count = 0;
}
/* Check for manufacturer ID every minute */
new_value = check_manufacturer(di);
if (new_value != di->manufacturer){
di->manufacturer = new_value;
change = 1;
if (di->manufacturer >= 0)
blocking_notifier_call_chain(¬ifier_list,
EVENT_RECOGNIZE_BATTERY, NULL);
if (di->manufacturer == NOT_RECOGNIZE)
blocking_notifier_call_chain(¬ifier_list,
EVENT_NOT_RECOGNIZE_BATTERY, NULL);
if (di->manufacturer == UNKNOW)
blocking_notifier_call_chain(¬ifier_list,
EVENT_UNKNOW_BATTERY, NULL);
}
update_status:
if (change) {
power_supply_changed(&di->bat);
// LED function
u8 value = 0;
if ((di->disable_led == 0) &&
!twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &value, 0x03)) {
if ((di->status == POWER_SUPPLY_STATUS_CHARGING)
&& (value & (1 << 2))) {
if(di->capacity < 90) {
/*
* Battery being charged, capacity < 90%: Amber LED
*/
omap4430_green_led_set(NULL, 0);
omap4430_orange_led_set(NULL, 255);
} else {
/*
* Battery being charged, capacity >= 90%: Green LED
*/
omap4430_orange_led_set(NULL, 0);
omap4430_green_led_set(NULL, 255);
}
} else if (di->status == POWER_SUPPLY_STATUS_FULL) {
if (value & (1 << 2)) {
/* Set to green if connected to USB */
omap4430_orange_led_set(NULL, 0);
omap4430_green_led_set(NULL, 255);
} else {
omap4430_green_led_set(NULL, 0);
omap4430_orange_led_set(NULL, 0);
}
}
}
}
if(di->err_count>=15){
printk("bat:%s get i2c error\n",__func__);
queue_delayed_work(bat_work_queue,&di->bat_monitor_work,
msecs_to_jiffies(10000 * 1));
}else
queue_delayed_work(bat_work_queue,&di->bat_monitor_work,
msecs_to_jiffies(5000 * 1));
}
}
