/*
* Battery low check remove
*/
static void battery_low_remove (struct mc13892_dev_info *di)
{
pmic_event_callback_t bat_event_callback;
bat_event_callback.func = battery_lobatli_callback;
bat_event_callback.param = (void *) di;
pmic_event_unsubscribe(EVENT_LOBATLI, bat_event_callback);
bat_event_callback.func = battery_lobathi_callback;
bat_event_callback.param = (void *) di;
pmic_event_unsubscribe(EVENT_LOBATHI, bat_event_callback);
battery_remove_inputdevice ();
}
/*!
* This function is used to un/subscribe on RTC event IT.
*
* @param event type of event.
* @param callback event callback function.
* @param sub define if Un/subscribe event.
*
* @return This function returns PMIC_SUCCESS if successful.
*/
PMIC_STATUS pmic_rtc_event(t_rtc_int event, void *callback, bool sub)
{
type_event rtc_event;
if (callback == NULL) {
return PMIC_ERROR;
} else {
rtc_callback.func = callback;
rtc_callback.param = NULL;
}
switch (event) {
case RTC_IT_ALARM:
rtc_event = EVENT_TODAI;
break;
case RTC_IT_1HZ:
rtc_event = EVENT_E1HZI;
break;
case RTC_IT_RST:
rtc_event = EVENT_RTCRSTI;
break;
default:
return PMIC_PARAMETER_ERROR;
}
if (sub == true) {
CHECK_ERROR(pmic_event_subscribe(rtc_event, rtc_callback));
} else {
CHECK_ERROR(pmic_event_unsubscribe(rtc_event, rtc_callback));
}
return PMIC_SUCCESS;
}
static int pmic_battery_remove(struct platform_device *pdev)
{
pmic_event_callback_t bat_event_callback;
struct mc13892_dev_info *di = platform_get_drvdata(pdev);
bat_event_callback.func = charger_online_event_callback;
bat_event_callback.param = (void *) di;
pmic_event_unsubscribe(EVENT_CHGDETI, bat_event_callback);
cancel_rearming_delayed_workqueue(di->monitor_wqueue,
&di->monitor_work);
cancel_rearming_delayed_workqueue(di->monitor_wqueue, &di->calc_capacity);
cancel_rearming_delayed_workqueue(chg_wq,
&chg_work);
destroy_workqueue(di->monitor_wqueue);
destroy_workqueue(chg_wq);
chg_wa_timer = 0;
chg_wa_is_active = 0;
disable_chg_timer = 0;
power_supply_unregister(&di->bat);
power_supply_unregister(&di->charger);
kfree(di);
return 0;
}
static int pmic_battery_remove(struct platform_device *pdev)
{
#ifdef CONFIG_MACH_MX51_ERDOS
struct mc13892_dev_info *di = platform_get_drvdata(pdev);
battery_low_remove (di);
#else
pmic_event_callback_t bat_event_callback;
struct mc13892_dev_info *di = platform_get_drvdata(pdev);
bat_event_callback.func = charger_online_event_callback;
bat_event_callback.param = (void *) di;
pmic_event_unsubscribe(EVENT_CHGDETI, bat_event_callback);
#endif /* CONFIG_MACH_MX51_ERDOS */
cancel_rearming_delayed_workqueue(di->monitor_wqueue,
&di->monitor_work);
destroy_workqueue(di->monitor_wqueue);
power_supply_unregister(&di->bat);
power_supply_unregister(&di->charger);
kfree(di);
return 0;
}
/*
* Battery low cancel_suspend
* cancel suspend mode
*/
static void battery_low_suspend_cancel (void)
{
int rc;
pmic_event_callback_t bat_event_callback;
/*
* interrupt restore
*/
pmic_event_for_resume ();
/*
* restore alarm
*/
if (pre_alarm [0] == 1) {
pre_alarm [0] = 0;
rc = pmic_write_reg (REG_RTC_ALARM, pre_alarm [1], 0x01FFFF);
if (rc == 0) {
rc = pmic_write_reg (REG_RTC_DAY_ALARM, pre_alarm [2], 0x007FFF);
}
if (rc != 0) {
printk ("battery_low_resume: restore TODA/DAYA error %d\n", rc);
}
bat_event_callback.func = battery_poll_callback;
bat_event_callback.param = (void *)0;
pmic_event_unsubscribe (EVENT_TODAI, bat_event_callback);
}
}
/*!
* This function wait the Alarm event
*
* @return This function returns PMIC_SUCCESS if successful.
*/
PMIC_STATUS pmic_rtc_wait_alarm(void)
{
DEFINE_WAIT(wait);
alarm_callback.func = callback_alarm_synchronous;
alarm_callback.param = NULL;
CHECK_ERROR(pmic_event_subscribe(EVENT_TODAI, alarm_callback));
prepare_to_wait(&queue_alarm, &wait, TASK_UNINTERRUPTIBLE);
schedule();
finish_wait(&queue_alarm, &wait);
CHECK_ERROR(pmic_event_unsubscribe(EVENT_TODAI, alarm_callback));
return PMIC_SUCCESS;
}
/*!
* This function is used to un/subscribe on battery event IT.
*
* @param event type of event.
* @param callback event callback function.
* @param sub define if Un/subscribe event.
*
* @return This function returns 0 if successful.
*/
PMIC_STATUS mc13783_battery_event(t_batt_event event, void *callback, bool sub)
{
pmic_event_callback_t bat_callback;
type_event bat_event;
bat_callback.func = callback;
bat_callback.param = NULL;
switch (event) {
case BAT_IT_CHG_DET:
bat_event = EVENT_CHGDETI;
break;
case BAT_IT_CHG_OVERVOLT:
bat_event = EVENT_CHGOVI;
break;
case BAT_IT_CHG_REVERSE:
bat_event = EVENT_CHGREVI;
break;
case BAT_IT_CHG_SHORT_CIRCUIT:
bat_event = EVENT_CHGSHORTI;
break;
case BAT_IT_CCCV:
bat_event = EVENT_CCCVI;
break;
case BAT_IT_BELOW_THRESHOLD:
bat_event = EVENT_CHRGCURRI;
break;
default:
return PMIC_PARAMETER_ERROR;
}
if (sub == true) {
CHECK_ERROR(pmic_event_subscribe(bat_event, bat_callback));
} else {
CHECK_ERROR(pmic_event_unsubscribe(bat_event, bat_callback));
}
return 0;
}
/*!
* This function implements IOCTL controls on a PMIC RTC device.
*
* @param inode pointer on the node
* @param file pointer on the file
* @param cmd the command
* @param arg the parameter
* @return This function returns 0 if successful.
*/
static int pmic_rtc_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg)
{
struct timeval *pmic_time = NULL;
if (_IOC_TYPE(cmd) != 'p')
return -ENOTTY;
if (arg) {
pmic_time = kmalloc(sizeof(struct timeval), GFP_KERNEL);
if (pmic_time == NULL)
return -ENOMEM;
/* if (copy_from_user(pmic_time, (struct timeval *)arg,
sizeof(struct timeval))) {
return -EFAULT;
} */
}
switch (cmd) {
case PMIC_RTC_SET_TIME:
if (copy_from_user(pmic_time, (struct timeval *)arg,
sizeof(struct timeval))) {
return -EFAULT;
}
pr_debug("SET RTC\n");
CHECK_ERROR(pmic_rtc_set_time(pmic_time));
break;
case PMIC_RTC_GET_TIME:
if (copy_to_user((struct timeval *)arg, pmic_time,
sizeof(struct timeval))) {
return -EFAULT;
}
pr_debug("GET RTC\n");
CHECK_ERROR(pmic_rtc_get_time(pmic_time));
break;
case PMIC_RTC_SET_ALARM:
if (copy_from_user(pmic_time, (struct timeval *)arg,
sizeof(struct timeval))) {
return -EFAULT;
}
pr_debug("SET RTC ALARM\n");
CHECK_ERROR(pmic_rtc_set_time_alarm(pmic_time));
break;
case PMIC_RTC_GET_ALARM:
if (copy_to_user((struct timeval *)arg, pmic_time,
sizeof(struct timeval))) {
return -EFAULT;
}
pr_debug("GET RTC ALARM\n");
CHECK_ERROR(pmic_rtc_get_time_alarm(pmic_time));
break;
case PMIC_RTC_WAIT_ALARM:
printk(KERN_INFO "WAIT ALARM...\n");
CHECK_ERROR(pmic_rtc_event_sub(RTC_IT_ALARM,
callback_test_sub));
CHECK_ERROR(pmic_rtc_wait_alarm());
printk(KERN_INFO "ALARM DONE\n");
CHECK_ERROR(pmic_rtc_event_unsub(RTC_IT_ALARM,
callback_test_sub));
break;
case PMIC_RTC_ALARM_REGISTER:
printk(KERN_INFO "PMIC RTC ALARM REGISTER\n");
alarm_callback.func = callback_alarm_asynchronous;
alarm_callback.param = NULL;
CHECK_ERROR(pmic_event_subscribe(EVENT_TODAI, alarm_callback));
break;
case PMIC_RTC_ALARM_UNREGISTER:
printk(KERN_INFO "PMIC RTC ALARM UNREGISTER\n");
alarm_callback.func = callback_alarm_asynchronous;
alarm_callback.param = NULL;
CHECK_ERROR(pmic_event_unsubscribe
(EVENT_TODAI, alarm_callback));
pmic_rtc_done = false;
break;
default:
pr_debug("%d unsupported ioctl command\n", (int)cmd);
return -EINVAL;
}
if (arg) {
if (copy_to_user((struct timeval *)arg, pmic_time,
sizeof(struct timeval))) {
return -EFAULT;
}
kfree(pmic_time);
}
return 0;
}
/*!
* This function implements IOCTL controls on a PMIC device.
*
* @param inode pointer on the node
* @param file pointer on the file
* @param cmd the command
* @param arg the parameter
* @return This function returns 0 if successful.
*/
static int pmic_dev_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg)
{
register_info reg_info;
pmic_event_callback_t event_sub;
type_event event;
int ret = 0;
if (_IOC_TYPE(cmd) != 'P')
return -ENOTTY;
switch (cmd) {
case PMIC_READ_REG:
if (copy_from_user(®_info, (register_info *) arg,
sizeof(register_info))) {
return -EFAULT;
}
ret =
pmic_read_reg(reg_info.reg, &(reg_info.reg_value),
0x00ffffff);
pr_debug("read reg %d %x\n", reg_info.reg, reg_info.reg_value);
if (copy_to_user((register_info *) arg, ®_info,
sizeof(register_info))) {
return -EFAULT;
}
break;
case PMIC_WRITE_REG:
if (copy_from_user(®_info, (register_info *) arg,
sizeof(register_info))) {
return -EFAULT;
}
ret =
pmic_write_reg(reg_info.reg, reg_info.reg_value,
0x00ffffff);
pr_debug("write reg %d %x\n", reg_info.reg, reg_info.reg_value);
if (copy_to_user((register_info *) arg, ®_info,
sizeof(register_info))) {
return -EFAULT;
}
break;
case PMIC_SUBSCRIBE:
if (get_user(event, (int __user *)arg)) {
return -EFAULT;
}
event_sub.func = callbackfn;
event_sub.param = (void *)event;
ret = pmic_event_subscribe(event, event_sub);
pr_debug("subscribe done\n");
break;
case PMIC_UNSUBSCRIBE:
if (get_user(event, (int __user *)arg)) {
return -EFAULT;
}
event_sub.func = callbackfn;
event_sub.param = (void *)event;
ret = pmic_event_unsubscribe(event, event_sub);
pr_debug("unsubscribe done\n");
break;
case PMIC_NOTIFY_USER:
if (get_user(event, (int __user *)arg)) {
return -EFAULT;
}
event_sub.func = user_notify_callback;
event_sub.param = (void *)event;
ret = pmic_event_subscribe(event, event_sub);
break;
case PMIC_GET_NOTIFY:
CIRC_REMOVE(event, pmic_events, CIRC_BUF_MAX);
if (put_user(event, (int __user *)arg)) {
return -EFAULT;
}
break;
default:
printk(KERN_ERR "%d unsupported ioctl command\n", (int)cmd);
return -EINVAL;
}
return ret;
}
