blob: e4c763287248e22422167051b9914a1c40fe4549 [file] [log] [blame]
/* Copyright (c) 2014, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#define pr_fmt(fmt) "BATTERY: %s: " fmt, __func__
#include <linux/module.h>
#include <linux/types.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/sched.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/fcntl.h>
#include <linux/uaccess.h>
#include <linux/batterydata-lib.h>
#include <linux/batterydata-interface.h>
struct battery_data {
dev_t dev_no;
struct class *battery_class;
struct device *battery_device;
struct cdev battery_cdev;
struct bms_battery_data *profile;
};
static struct battery_data *the_battery;
static int battery_data_open(struct inode *inode, struct file *file)
{
struct battery_data *battery = container_of(inode->i_cdev,
struct battery_data, battery_cdev);
pr_debug("battery_data device opened\n");
file->private_data = battery;
return 0;
}
static long battery_data_ioctl(struct file *file, unsigned int cmd,
unsigned long arg)
{
struct battery_data *battery = file->private_data;
struct battery_params __user *bp_user =
(struct battery_params __user *)arg;
struct battery_params bp;
int soc, rbatt_sf, slope, fcc_mah;
int rc = 0;
if (!battery->profile) {
pr_err("Battery data not set!\n");
return -EINVAL;
}
if (copy_from_user(&bp, bp_user, sizeof(bp))) {
pr_err("copy_from_user failed\n");
return -EFAULT;
}
switch (cmd) {
case BPIOCXSOC:
soc = interpolate_pc(battery->profile->pc_temp_ocv_lut,
bp.batt_temp, bp.ocv_uv / 1000);
rc = put_user(soc, &bp_user->soc);
if (rc) {
pr_err("BPIOCXSOC: Failed to 'put_user' rc=%d\n", rc);
goto ret_err;
}
pr_debug("BPIOCXSOC: ocv=%d batt_temp=%d soc=%d\n",
bp.ocv_uv / 1000, bp.batt_temp, soc);
break;
case BPIOCXRBATT:
rbatt_sf = interpolate_scalingfactor(
battery->profile->rbatt_sf_lut,
bp.batt_temp, bp.soc);
rc = put_user(rbatt_sf, &bp_user->rbatt_sf);
if (rc) {
pr_err("BPIOCXRBATT: Failed to 'put_user' rc=%d\n", rc);
goto ret_err;
}
pr_debug("BPIOCXRBATT: soc=%d batt_temp=%d rbatt_sf=%d\n",
bp.soc, bp.batt_temp, rbatt_sf);
break;
case BPIOCXSLOPE:
slope = interpolate_slope(battery->profile->pc_temp_ocv_lut,
bp.batt_temp, bp.soc);
rc = put_user(slope, &bp_user->slope);
if (rc) {
pr_err("BPIOCXSLOPE: Failed to 'put_user' rc=%d\n", rc);
goto ret_err;
}
pr_debug("BPIOCXSLOPE: soc=%d batt_temp=%d slope=%d\n",
bp.soc, bp.batt_temp, slope);
break;
case BPIOCXFCC:
fcc_mah = interpolate_fcc(battery->profile->fcc_temp_lut,
bp.batt_temp);
rc = put_user(fcc_mah, &bp_user->fcc_mah);
if (rc) {
pr_err("BPIOCXFCC: Failed to 'put_user' rc=%d\n", rc);
goto ret_err;
}
pr_debug("BPIOCXFCC: batt_temp=%d fcc_mah=%d\n",
bp.batt_temp, fcc_mah);
break;
default:
pr_err("IOCTL %d not supported\n", cmd);
rc = -EINVAL;
}
ret_err:
return rc;
}
static int battery_data_release(struct inode *inode, struct file *file)
{
pr_debug("battery_data device closed\n");
return 0;
}
static const struct file_operations battery_data_fops = {
.owner = THIS_MODULE,
.open = battery_data_open,
.unlocked_ioctl = battery_data_ioctl,
.compat_ioctl = battery_data_ioctl,
.release = battery_data_release,
};
int config_battery_data(struct bms_battery_data *profile)
{
if (!the_battery) {
pr_err("Battery data not intialized\n");
return -ENODEV;
}
the_battery->profile = profile;
pr_debug("Battery profile set - %s\n",
the_battery->profile->battery_type);
return 0;
}
int batterydata_init(void)
{
int rc;
struct battery_data *battery;
battery = kzalloc(sizeof(*battery), GFP_KERNEL);
if (!battery) {
pr_err("Unable to allocate memory\n");
return -ENOMEM;
}
/* character device to access the battery-data from userspace */
rc = alloc_chrdev_region(&battery->dev_no, 0, 1, "battery_data");
if (rc) {
pr_err("Unable to allocate chrdev rc=%d\n", rc);
return rc;
}
cdev_init(&battery->battery_cdev, &battery_data_fops);
rc = cdev_add(&battery->battery_cdev, battery->dev_no, 1);
if (rc) {
pr_err("Unable to add battery_cdev rc=%d\n", rc);
goto unregister_chrdev;
}
battery->battery_class = class_create(THIS_MODULE, "battery_data");
if (IS_ERR_OR_NULL(battery->battery_class)) {
pr_err("Fail to create battery class\n");
rc = -ENODEV;
goto delete_cdev;
}
battery->battery_device = device_create(battery->battery_class,
NULL, battery->dev_no,
NULL, "battery_data");
if (IS_ERR(battery->battery_device)) {
pr_err("Fail to create battery_device device\n");
rc = -ENODEV;
goto delete_cdev;
}
the_battery = battery;
pr_info("Battery-data device created!\n");
return 0;
delete_cdev:
cdev_del(&battery->battery_cdev);
unregister_chrdev:
unregister_chrdev_region(battery->dev_no, 1);
the_battery = NULL;
return rc;
}
subsys_initcall(batterydata_init);
static void batterydata_exit(void)
{
if (the_battery) {
device_destroy(the_battery->battery_class, the_battery->dev_no);
cdev_del(&the_battery->battery_cdev);
unregister_chrdev_region(the_battery->dev_no, 1);
}
kfree(the_battery);
the_battery = NULL;
}
module_exit(batterydata_exit);
MODULE_DESCRIPTION("Battery-data Interface driver");
MODULE_LICENSE("GPL v2");