490 lines
13 KiB
C
490 lines
13 KiB
C
/*
|
|
* Copyright (C) 2015 MediaTek Inc.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License 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) KBUILD_MODNAME ": %s: " fmt, __func__
|
|
|
|
#include <linux/types.h>
|
|
#include <linux/init.h>
|
|
#include <linux/module.h>
|
|
#include <linux/device.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/hrtimer.h>
|
|
#include <linux/ktime.h>
|
|
#include <linux/workqueue.h>
|
|
#include <linux/mutex.h>
|
|
#include <linux/of.h>
|
|
#include <linux/list.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/slab.h>
|
|
|
|
#include "flashlight-core.h"
|
|
#include "flashlight-dt.h"
|
|
|
|
#include <linux/mfd/sm/sm5714/sm5714.h>
|
|
|
|
#define SM5714_NAME "flashlights-sm5714"
|
|
|
|
/* define level */
|
|
#define SM5714_LEVEL_NUM 60
|
|
#define SM5714_LEVEL_TORCH 11
|
|
#define SM5714_HW_TIMEOUT 1600 /* ms */
|
|
#define SM5714_DUTY_STEP 25
|
|
|
|
#define VOLTAGE_DECREASE 0
|
|
#define VOLTAGE_INCREASE 1
|
|
#define VOLTAGE_NONE 2
|
|
#define VOLTAGE_PRE_ON_DONE 3
|
|
|
|
/* define mutex and work queue */
|
|
static DEFINE_MUTEX(sm5714_mutex);
|
|
static struct work_struct sm5714_work;
|
|
static struct work_struct sm5714_voltage_work;
|
|
|
|
static int volt_direction = VOLTAGE_NONE;
|
|
/* define usage count */
|
|
static int use_count;
|
|
static int sm5714_current_level;
|
|
|
|
/* platform data */
|
|
struct sm5714_flashlight_platform_data {
|
|
int channel_num;
|
|
struct flashlight_device_id *dev_id;
|
|
};
|
|
|
|
|
|
static int sm5714_is_torch(int level)
|
|
{
|
|
if (level > SM5714_LEVEL_TORCH)
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int sm5714_verify_level(int level)
|
|
{
|
|
if (level < 0)
|
|
level = 0;
|
|
else if (level >= SM5714_LEVEL_NUM)
|
|
level = SM5714_LEVEL_NUM - 1;
|
|
|
|
return level;
|
|
}
|
|
|
|
/* set flashlight level */
|
|
static void sm5714_set_level(int level)
|
|
{
|
|
level = sm5714_verify_level(level);
|
|
sm5714_current_level = level;
|
|
}
|
|
|
|
static void sm5714_adjust_voltage()
|
|
{
|
|
if(volt_direction == VOLTAGE_DECREASE) {
|
|
sm5714_fled_mode_ctrl(SM5714_FLED_MODE_PREPARE_FLASH, 0);
|
|
pr_info("[%s]%d Down Voltage set On \n" ,__func__,__LINE__);
|
|
}
|
|
else if(volt_direction == VOLTAGE_INCREASE) {
|
|
volt_direction = VOLTAGE_NONE;
|
|
sm5714_fled_mode_ctrl(SM5714_FLED_MODE_CLOSE_FLASH, 0);
|
|
pr_info("[%s]%d Down Voltage set Clear \n" ,__func__,__LINE__);
|
|
}
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Timer and work queue
|
|
*****************************************************************************/
|
|
static struct hrtimer sm5714_timer;
|
|
static unsigned int sm5714_timeout_ms;
|
|
|
|
static void sm5714_work_disable(struct work_struct *data)
|
|
{
|
|
pr_debug("work queue callback\n");
|
|
sm5714_fled_mode_ctrl(SM5714_FLED_MODE_OFF, 0);
|
|
}
|
|
|
|
static enum hrtimer_restart sm5714_timer_func(struct hrtimer *timer)
|
|
{
|
|
schedule_work(&sm5714_work);
|
|
volt_direction = VOLTAGE_INCREASE;
|
|
schedule_work(&sm5714_voltage_work);
|
|
return HRTIMER_NORESTART;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* Flashlight operations
|
|
*****************************************************************************/
|
|
static int sm5714_ioctl(unsigned int cmd, unsigned long arg)
|
|
{
|
|
struct flashlight_dev_arg *fl_arg;
|
|
int channel;
|
|
ktime_t ktime;
|
|
unsigned int s;
|
|
unsigned int ns;
|
|
|
|
fl_arg = (struct flashlight_dev_arg *)arg;
|
|
channel = fl_arg->channel;
|
|
|
|
switch (cmd) {
|
|
case FLASH_IOC_SET_TIME_OUT_TIME_MS:
|
|
pr_debug("FLASH_IOC_SET_TIME_OUT_TIME_MS(%d): %d\n",
|
|
channel, (int)fl_arg->arg);
|
|
sm5714_timeout_ms = fl_arg->arg;
|
|
break;
|
|
|
|
case FLASH_IOC_SET_DUTY:
|
|
pr_debug("FLASH_IOC_SET_DUTY(%d): %d\n",
|
|
channel, (int)fl_arg->arg);
|
|
sm5714_set_level(fl_arg->arg);
|
|
break;
|
|
|
|
case FLASH_IOC_SET_ONOFF:
|
|
pr_debug("FLASH_IOC_SET_ONOFF(%d): %d\n",
|
|
channel, (int)fl_arg->arg);
|
|
if (fl_arg->arg == 1) {
|
|
if (sm5714_timeout_ms) {
|
|
s = sm5714_timeout_ms / 1000;
|
|
ns = sm5714_timeout_ms % 1000 * 1000000;
|
|
ktime = ktime_set(s, ns);
|
|
hrtimer_start(&sm5714_timer, ktime,
|
|
HRTIMER_MODE_REL);
|
|
}
|
|
//0 based indexing for level
|
|
if(sm5714_is_torch(sm5714_current_level)) {
|
|
pr_debug("TORCH MODE");
|
|
sm5714_fled_mode_ctrl(SM5714_FLED_MODE_TORCH_FLASH, (sm5714_current_level + 1) * SM5714_DUTY_STEP);
|
|
}
|
|
else {
|
|
pr_debug("FLASH MODE");
|
|
sm5714_fled_mode_ctrl(SM5714_FLED_MODE_MAIN_FLASH, (sm5714_current_level + 1) * SM5714_DUTY_STEP);
|
|
}
|
|
} else {
|
|
sm5714_fled_mode_ctrl(SM5714_FLED_MODE_OFF, 0);
|
|
hrtimer_cancel(&sm5714_timer);
|
|
if(volt_direction == VOLTAGE_PRE_ON_DONE) {
|
|
volt_direction = VOLTAGE_INCREASE;
|
|
schedule_work(&sm5714_voltage_work);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case FLASH_IOC_PRE_ON:
|
|
pr_debug("FLASH_IOC_PRE_ON(%d)\n", channel);
|
|
if(volt_direction == VOLTAGE_DECREASE) {
|
|
volt_direction = VOLTAGE_PRE_ON_DONE;
|
|
}
|
|
break;
|
|
|
|
case FLASH_IOC_GET_DUTY_NUMBER:
|
|
pr_debug("FLASH_IOC_GET_DUTY_NUMBER(%d)\n", channel);
|
|
fl_arg->arg = SM5714_LEVEL_NUM;
|
|
break;
|
|
|
|
case FLASH_IOC_GET_MAX_TORCH_DUTY:
|
|
pr_debug("FLASH_IOC_GET_MAX_TORCH_DUTY(%d)\n", channel);
|
|
fl_arg->arg = SM5714_LEVEL_TORCH - 1;
|
|
break;
|
|
|
|
case FLASH_IOC_GET_DUTY_CURRENT:
|
|
fl_arg->arg = sm5714_verify_level(fl_arg->arg);
|
|
pr_debug("FLASH_IOC_GET_DUTY_CURRENT(%d): %d\n",
|
|
channel, (int)fl_arg->arg);
|
|
fl_arg->arg = ((fl_arg->arg)+1) * SM5714_DUTY_STEP;
|
|
break;
|
|
|
|
case FLASH_IOC_GET_HW_TIMEOUT:
|
|
pr_debug("FLASH_IOC_GET_HW_TIMEOUT(%d)\n", channel);
|
|
fl_arg->arg = SM5714_HW_TIMEOUT;
|
|
break;
|
|
|
|
case FLASH_IOC_SET_SCENARIO:
|
|
pr_debug("FLASH_IOC_SET_SCENARIO(%d)\n", channel);
|
|
if(volt_direction == VOLTAGE_DECREASE) {
|
|
volt_direction = VOLTAGE_INCREASE;
|
|
schedule_work(&sm5714_voltage_work);
|
|
}
|
|
break;
|
|
|
|
case FLASH_IOC_SET_VOLTAGE:
|
|
pr_debug("FLASH_IOC_SET_VOLTAGE(%d)\n", channel);
|
|
volt_direction = VOLTAGE_DECREASE;
|
|
schedule_work(&sm5714_voltage_work);
|
|
break;
|
|
|
|
default:
|
|
pr_err("No such command and arg(%d): (%d, %d)\n",
|
|
channel, _IOC_NR(cmd), (int)fl_arg->arg);
|
|
return -ENOTTY;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int sm5714_open(void)
|
|
{
|
|
/* Move to set driver for saving power */
|
|
return 0;
|
|
}
|
|
|
|
static int sm5714_release(void)
|
|
{
|
|
/* Move to set driver for saving power */
|
|
return 0;
|
|
}
|
|
|
|
static int sm5714_set_driver(int set)
|
|
{
|
|
/* set chip and usage count */
|
|
mutex_lock(&sm5714_mutex);
|
|
if (set) {
|
|
use_count++;
|
|
pr_debug("Set driver: %d\n", use_count);
|
|
} else {
|
|
use_count--;
|
|
if (!use_count)
|
|
sm5714_fled_mode_ctrl(SM5714_FLED_MODE_OFF, 0);
|
|
if (use_count < 0)
|
|
use_count = 0;
|
|
pr_debug("Unset driver: %d\n", use_count);
|
|
}
|
|
mutex_unlock(&sm5714_mutex);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t sm5714_strobe_store(struct flashlight_arg arg)
|
|
{
|
|
sm5714_set_driver(1);
|
|
sm5714_set_level(arg.level);
|
|
sm5714_timeout_ms = 0;
|
|
sm5714_set_driver(0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct flashlight_operations sm5714_ops = {
|
|
sm5714_open,
|
|
sm5714_release,
|
|
sm5714_ioctl,
|
|
sm5714_strobe_store,
|
|
sm5714_set_driver
|
|
};
|
|
|
|
static int sm5714_parse_dt(struct device *dev,
|
|
struct sm5714_flashlight_platform_data *pdata)
|
|
{
|
|
struct device_node *np, *cnp;
|
|
u32 decouple = 0;
|
|
int i = 0;
|
|
|
|
if (!dev || !dev->of_node || !pdata)
|
|
return -ENODEV;
|
|
|
|
np = dev->of_node;
|
|
|
|
pdata->channel_num = of_get_child_count(np);
|
|
if (!pdata->channel_num) {
|
|
pr_info("Parse no dt, node.\n");
|
|
return 0;
|
|
}
|
|
pr_info("Channel number(%d).\n", pdata->channel_num);
|
|
|
|
if (of_property_read_u32(np, "decouple", &decouple))
|
|
pr_info("Parse no dt, decouple.\n");
|
|
|
|
pdata->dev_id = devm_kzalloc(dev,
|
|
pdata->channel_num *
|
|
sizeof(struct flashlight_device_id),
|
|
GFP_KERNEL);
|
|
if (!pdata->dev_id)
|
|
return -ENOMEM;
|
|
|
|
for_each_child_of_node(np, cnp) {
|
|
if (of_property_read_u32(cnp, "type", &pdata->dev_id[i].type))
|
|
goto err_node_put;
|
|
if (of_property_read_u32(cnp, "ct", &pdata->dev_id[i].ct))
|
|
goto err_node_put;
|
|
if (of_property_read_u32(cnp, "part", &pdata->dev_id[i].part))
|
|
goto err_node_put;
|
|
snprintf(pdata->dev_id[i].name, FLASHLIGHT_NAME_SIZE,
|
|
SM5714_NAME);
|
|
pdata->dev_id[i].channel = i + 1;
|
|
pdata->dev_id[i].decouple = decouple;
|
|
|
|
pr_info("Parse dt (type,ct,part,name,channel,decouple)=(%d,%d,%d,%s,%d,%d).\n",
|
|
pdata->dev_id[i].type, pdata->dev_id[i].ct,
|
|
pdata->dev_id[i].part, pdata->dev_id[i].name,
|
|
pdata->dev_id[i].channel,
|
|
pdata->dev_id[i].decouple);
|
|
i++;
|
|
}
|
|
|
|
return 0;
|
|
|
|
err_node_put:
|
|
of_node_put(cnp);
|
|
return -EINVAL;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Platform device and driver
|
|
*****************************************************************************/
|
|
static int sm5714_probe(struct platform_device *pdev)
|
|
{
|
|
struct sm5714_flashlight_platform_data *pdata = dev_get_platdata(&pdev->dev);
|
|
int err;
|
|
int i;
|
|
|
|
pr_debug("Probe start.\n");
|
|
|
|
if (!pdata) {
|
|
pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
|
|
if (!pdata) {
|
|
err = -ENOMEM;
|
|
goto err_free;
|
|
}
|
|
pdev->dev.platform_data = pdata;
|
|
err = sm5714_parse_dt(&pdev->dev, pdata);
|
|
if (err)
|
|
goto err_free;
|
|
}
|
|
|
|
/* init work queue */
|
|
INIT_WORK(&sm5714_work, sm5714_work_disable);
|
|
INIT_WORK(&sm5714_voltage_work, sm5714_adjust_voltage);
|
|
|
|
/* init timer */
|
|
hrtimer_init(&sm5714_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
|
|
sm5714_timer.function = sm5714_timer_func;
|
|
sm5714_timeout_ms = SM5714_HW_TIMEOUT;
|
|
|
|
/* clear usage count */
|
|
use_count = 0;
|
|
|
|
/* register flashlight device */
|
|
if (pdata->channel_num) {
|
|
for (i = 0; i < pdata->channel_num; i++)
|
|
if (flashlight_dev_register_by_device_id(
|
|
&pdata->dev_id[i],
|
|
&sm5714_ops)) {
|
|
err = -EFAULT;
|
|
goto err_free;
|
|
}
|
|
} else {
|
|
if (flashlight_dev_register(SM5714_NAME, &sm5714_ops)) {
|
|
err = -EFAULT;
|
|
goto err_free;
|
|
}
|
|
}
|
|
|
|
pr_debug("Probe done.\n");
|
|
return 0;
|
|
err_free:
|
|
return err;
|
|
}
|
|
|
|
static int sm5714_remove(struct platform_device *pdev)
|
|
{
|
|
struct sm5714_flashlight_platform_data *pdata = dev_get_platdata(&pdev->dev);
|
|
int i;
|
|
|
|
pr_debug("Remove start.\n");
|
|
|
|
/* unregister flashlight device */
|
|
if (pdata && pdata->channel_num)
|
|
for (i = 0; i < pdata->channel_num; i++)
|
|
flashlight_dev_unregister_by_device_id(
|
|
&pdata->dev_id[i]);
|
|
else
|
|
flashlight_dev_unregister(SM5714_NAME);
|
|
|
|
/* flush work queue */
|
|
flush_work(&sm5714_work);
|
|
flush_work(&sm5714_voltage_work);
|
|
|
|
pr_debug("Remove done.\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_OF
|
|
static const struct of_device_id sm5714_of_match[] = {
|
|
{.compatible = SM5714_DTNAME},
|
|
{},
|
|
};
|
|
MODULE_DEVICE_TABLE(of, sm5714_of_match);
|
|
#else
|
|
static struct platform_device sm5714_platform_device[] = {
|
|
{
|
|
.name = SM5714_NAME,
|
|
.id = 0,
|
|
.dev = {}
|
|
},
|
|
{}
|
|
};
|
|
MODULE_DEVICE_TABLE(platform, sm5714_platform_device);
|
|
#endif
|
|
|
|
static struct platform_driver sm5714_platform_driver = {
|
|
.probe = sm5714_probe,
|
|
.remove = sm5714_remove,
|
|
.driver = {
|
|
.name = SM5714_NAME,
|
|
.owner = THIS_MODULE,
|
|
#ifdef CONFIG_OF
|
|
.of_match_table = sm5714_of_match,
|
|
#endif
|
|
},
|
|
};
|
|
|
|
static int __init flashlight_sm5714_init(void)
|
|
{
|
|
int ret;
|
|
|
|
pr_debug("Init start.\n");
|
|
|
|
#ifndef CONFIG_OF
|
|
ret = platform_device_register(&sm5714_platform_device);
|
|
if (ret) {
|
|
pr_err("Failed to register platform device\n");
|
|
return ret;
|
|
}
|
|
#else
|
|
ret = platform_driver_register(&sm5714_platform_driver);
|
|
if (ret) {
|
|
pr_err("Failed to register platform driver\n");
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
pr_debug("Init done.\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void __exit flashlight_sm5714_exit(void)
|
|
{
|
|
pr_debug("Exit start.\n");
|
|
|
|
platform_driver_unregister(&sm5714_platform_driver);
|
|
|
|
pr_debug("Exit done.\n");
|
|
}
|
|
|
|
module_init(flashlight_sm5714_init);
|
|
module_exit(flashlight_sm5714_exit);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_AUTHOR("Civashritt A B <ab.civa@samsung.com>");
|
|
MODULE_DESCRIPTION("SAMSUNG SM5714 FlashLight Driver");
|