1836 lines
46 KiB
C
1836 lines
46 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright (C) 2019-2021 Samsung Electronics Co. Ltd.
|
|
*/
|
|
|
|
#define pr_fmt(fmt) "[VIB] " fmt
|
|
#include <linux/device.h>
|
|
#include <linux/module.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/hrtimer.h>
|
|
#include <linux/of_device.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/err.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/vibrator/sec_vibrator.h>
|
|
#if IS_ENABLED(CONFIG_SEC_VIB_NOTIFIER)
|
|
#include <linux/vibrator/sec_vibrator_notifier.h>
|
|
#endif
|
|
#if IS_ENABLED(CONFIG_BATTERY_SAMSUNG)
|
|
#if defined(CONFIG_BATTERY_GKI)
|
|
#include <linux/battery/sec_battery_common.h>
|
|
#else
|
|
#include <linux/battery/common/sb_psy.h>
|
|
#endif
|
|
#endif
|
|
#if defined(CONFIG_SEC_KUNIT)
|
|
#include "kunit_test/sec_vibrator_test.h"
|
|
#else
|
|
#define __visible_for_testing static
|
|
#endif
|
|
|
|
enum {
|
|
VIB_NO_COMPEMSATION = 0,
|
|
VIB_COMPENSATION_WAY1,
|
|
VIB_COMPENSATION_WAY2,
|
|
};
|
|
|
|
static const int kMaxBufSize = 7;
|
|
static const int kMaxHapticStepSize = 7;
|
|
static const char *str_newline = "\n";
|
|
|
|
static struct sec_vibrator_drvdata *g_ddata;
|
|
|
|
static char vib_event_cmd[MAX_STR_LEN_EVENT_CMD];
|
|
|
|
static const char sec_vib_event_cmd[EVENT_CMD_MAX][MAX_STR_LEN_EVENT_CMD] = {
|
|
[EVENT_CMD_NONE] = "NONE",
|
|
[EVENT_CMD_FOLDER_CLOSE] = "FOLDER_CLOSE",
|
|
[EVENT_CMD_FOLDER_OPEN] = "FOLDER_OPEN",
|
|
[EVENT_CMD_ACCESSIBILITY_BOOST_ON] = "ACCESSIBILITY_BOOST_ON",
|
|
[EVENT_CMD_ACCESSIBILITY_BOOST_OFF] = "ACCESSIBILITY_BOOST_OFF",
|
|
[EVENT_CMD_TENT_CLOSE] = "FOLDER_TENT_CLOSE",
|
|
[EVENT_CMD_TENT_OPEN] = "FOLDER_TENT_OPEN",
|
|
};
|
|
|
|
static struct sec_vibrator_pdata sec_vibrator_pdata = {
|
|
.probe_done = false,
|
|
.normal_ratio = 100,
|
|
.high_temp_ratio = SEC_VIBRATOR_DEFAULT_HIGH_TEMP_RATIO,
|
|
.high_temp_ref = SEC_VIBRATOR_DEFAULT_HIGH_TEMP_REF,
|
|
};
|
|
|
|
#if IS_ENABLED(CONFIG_SEC_VIB_NOTIFIER)
|
|
static struct vib_notifier_context vib_notifier;
|
|
static struct blocking_notifier_head sec_vib_nb_head = BLOCKING_NOTIFIER_INIT(sec_vib_nb_head);
|
|
|
|
int sec_vib_notifier_register(struct notifier_block *noti_block)
|
|
{
|
|
int ret = 0;
|
|
|
|
pr_info("%s\n", __func__);
|
|
|
|
if (!noti_block)
|
|
return -EINVAL;
|
|
|
|
ret = blocking_notifier_chain_register(&sec_vib_nb_head, noti_block);
|
|
if (ret < 0)
|
|
pr_err("%s: failed(%d)\n", __func__, ret);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(sec_vib_notifier_register);
|
|
|
|
int sec_vib_notifier_unregister(struct notifier_block *noti_block)
|
|
{
|
|
int ret = 0;
|
|
|
|
pr_info("%s\n", __func__);
|
|
|
|
if (!noti_block)
|
|
return -EINVAL;
|
|
|
|
ret = blocking_notifier_chain_unregister(&sec_vib_nb_head, noti_block);
|
|
if (ret < 0)
|
|
pr_err("%s: failed(%d)\n", __func__, ret);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(sec_vib_notifier_unregister);
|
|
|
|
static int sec_vib_notifier_notify(int en, struct sec_vibrator_drvdata *ddata)
|
|
{
|
|
int ret = 0;
|
|
|
|
if (!ddata) {
|
|
pr_err("%s : ddata is NULL\n", __func__);
|
|
return -ENODATA;
|
|
}
|
|
|
|
vib_notifier.index = ddata->index;
|
|
vib_notifier.timeout = ddata->timeout;
|
|
|
|
pr_info("%s: %s, idx: %d timeout: %d\n", __func__, en ? "ON" : "OFF",
|
|
vib_notifier.index, vib_notifier.timeout);
|
|
|
|
ret = blocking_notifier_call_chain(&sec_vib_nb_head, en, &vib_notifier);
|
|
|
|
switch (ret) {
|
|
case NOTIFY_DONE:
|
|
case NOTIFY_OK:
|
|
pr_info("%s done(0x%x)\n", __func__, ret);
|
|
break;
|
|
default:
|
|
pr_info("%s failed(0x%x)\n", __func__, ret);
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
#endif /* if IS_ENABLED(CONFIG_SEC_VIB_NOTIFIER) */
|
|
|
|
#if IS_ENABLED(CONFIG_BATTERY_SAMSUNG)
|
|
static int sec_vibrator_check_temp(struct sec_vibrator_drvdata *ddata)
|
|
{
|
|
int ret = 0;
|
|
union power_supply_propval value = {0, };
|
|
|
|
if (!ddata) {
|
|
pr_err("%s : ddata is NULL\n", __func__);
|
|
return -ENODATA;
|
|
}
|
|
|
|
if (!ddata->vib_ops->set_tuning_with_temp)
|
|
return -ENOSYS;
|
|
|
|
psy_do_property("battery", get, POWER_SUPPLY_PROP_TEMP, value);
|
|
|
|
ret = ddata->vib_ops->set_tuning_with_temp(ddata->dev, value.intval);
|
|
|
|
if (ret)
|
|
pr_err("%s error(%d)\n", __func__, ret);
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
__visible_for_testing int sec_vibrator_set_enable(struct sec_vibrator_drvdata *ddata, bool en)
|
|
{
|
|
int ret = 0;
|
|
|
|
if (!ddata) {
|
|
pr_err("%s : ddata is NULL\n", __func__);
|
|
return -ENODATA;
|
|
}
|
|
|
|
if (!ddata->vib_ops->enable)
|
|
return -ENOSYS;
|
|
|
|
ret = ddata->vib_ops->enable(ddata->dev, en);
|
|
if (ret)
|
|
pr_err("%s error(%d)\n", __func__, ret);
|
|
|
|
#if IS_ENABLED(CONFIG_SEC_VIB_NOTIFIER)
|
|
sec_vib_notifier_notify(en, ddata);
|
|
#endif
|
|
return ret;
|
|
}
|
|
|
|
__visible_for_testing int sec_vibrator_set_intensity(struct sec_vibrator_drvdata *ddata, int intensity)
|
|
{
|
|
int ret = 0;
|
|
|
|
if (!ddata) {
|
|
pr_err("%s : ddata is NULL\n", __func__);
|
|
return -ENODATA;
|
|
}
|
|
|
|
if (!ddata->vib_ops->set_intensity)
|
|
return -ENOSYS;
|
|
|
|
if ((intensity < -(MAX_INTENSITY)) || (intensity > MAX_INTENSITY)) {
|
|
pr_err("%s out of range(%d)\n", __func__, intensity);
|
|
return -EINVAL;
|
|
}
|
|
|
|
ret = ddata->vib_ops->set_intensity(ddata->dev, intensity);
|
|
|
|
if (ret)
|
|
pr_err("%s error(%d)\n", __func__, ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
__visible_for_testing int sec_vibrator_set_frequency(struct sec_vibrator_drvdata *ddata, int frequency)
|
|
{
|
|
int ret = 0;
|
|
|
|
if (!ddata) {
|
|
pr_err("%s : ddata is NULL\n", __func__);
|
|
return -ENODATA;
|
|
}
|
|
|
|
if (!ddata->vib_ops->set_frequency)
|
|
return -ENOSYS;
|
|
|
|
if ((frequency < FREQ_ALERT) ||
|
|
((frequency >= FREQ_MAX) && (frequency < HAPTIC_ENGINE_FREQ_MIN)) ||
|
|
(frequency > HAPTIC_ENGINE_FREQ_MAX)) {
|
|
pr_err("%s out of range(%d)\n", __func__, frequency);
|
|
return -EINVAL;
|
|
}
|
|
|
|
ret = ddata->vib_ops->set_frequency(ddata->dev, frequency);
|
|
|
|
if (ret)
|
|
pr_err("%s error(%d)\n", __func__, ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
__visible_for_testing int sec_vibrator_set_overdrive(struct sec_vibrator_drvdata *ddata, bool en)
|
|
{
|
|
int ret = 0;
|
|
|
|
if (!ddata) {
|
|
pr_err("%s : ddata is NULL\n", __func__);
|
|
return -ENODATA;
|
|
}
|
|
|
|
if (!ddata->vib_ops->set_overdrive)
|
|
return -ENOSYS;
|
|
|
|
ret = ddata->vib_ops->set_overdrive(ddata->dev, en);
|
|
if (ret)
|
|
pr_err("%s error(%d)\n", __func__, ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void sec_vibrator_haptic_enable(struct sec_vibrator_drvdata *ddata)
|
|
{
|
|
if (!ddata) {
|
|
pr_err("%s : ddata is NULL\n", __func__);
|
|
return;
|
|
}
|
|
|
|
#if IS_ENABLED(CONFIG_BATTERY_SAMSUNG)
|
|
sec_vibrator_check_temp(ddata);
|
|
#endif
|
|
|
|
sec_vibrator_set_frequency(ddata, ddata->frequency);
|
|
sec_vibrator_set_intensity(ddata, ddata->intensity);
|
|
sec_vibrator_set_enable(ddata, true);
|
|
|
|
if (ddata->vib_ops->set_frequency)
|
|
pr_info("freq:%d, intensity:%d, %dms\n", ddata->frequency, ddata->intensity, ddata->timeout);
|
|
else if (ddata->vib_ops->set_intensity)
|
|
pr_info("intensity:%d, %dms\n", ddata->intensity, ddata->timeout);
|
|
else
|
|
pr_info("%dms\n", ddata->timeout);
|
|
}
|
|
|
|
static void sec_vibrator_haptic_disable(struct sec_vibrator_drvdata *ddata)
|
|
{
|
|
if (!ddata) {
|
|
pr_err("%s : ddata is NULL\n", __func__);
|
|
return;
|
|
}
|
|
|
|
/* clear common variables */
|
|
ddata->index = 0;
|
|
|
|
/* clear haptic engine variables */
|
|
ddata->f_packet_en = false;
|
|
ddata->packet_cnt = 0;
|
|
ddata->packet_size = 0;
|
|
|
|
sec_vibrator_set_enable(ddata, false);
|
|
sec_vibrator_set_overdrive(ddata, false);
|
|
sec_vibrator_set_frequency(ddata, FREQ_ALERT);
|
|
sec_vibrator_set_intensity(ddata, 0);
|
|
|
|
if (ddata->timeout > 0)
|
|
pr_info("timeout, off\n");
|
|
else
|
|
pr_info("off\n");
|
|
}
|
|
|
|
static void sec_vibrator_engine_run_packet(struct sec_vibrator_drvdata *ddata, struct vib_packet packet)
|
|
{
|
|
int frequency = packet.freq;
|
|
int intensity = packet.intensity;
|
|
int overdrive = packet.overdrive;
|
|
int fifo = packet.fifo_flag;
|
|
int file_num = 0;
|
|
|
|
if (!ddata) {
|
|
pr_err("%s : ddata is NULL\n", __func__);
|
|
return;
|
|
}
|
|
|
|
if (!ddata->f_packet_en) {
|
|
pr_err("haptic packet is empty\n");
|
|
return;
|
|
}
|
|
|
|
if (fifo == 0)
|
|
pr_info("%s [%d] freq:%d, intensity:%d, time:%d overdrive: %d\n",
|
|
__func__, ddata->packet_cnt, frequency, intensity,
|
|
ddata->timeout, overdrive);
|
|
else
|
|
pr_info("%s [%d] fifo num:%d, intensity:%d, time:%d overdrive: %d\n",
|
|
__func__, ddata->packet_cnt, frequency, intensity,
|
|
ddata->timeout, overdrive);
|
|
|
|
sec_vibrator_set_overdrive(ddata, overdrive);
|
|
if (fifo == 0)
|
|
sec_vibrator_set_frequency(ddata, frequency);
|
|
else
|
|
file_num = frequency;
|
|
|
|
if (intensity) {
|
|
if (fifo == 0) {
|
|
sec_vibrator_set_intensity(ddata, intensity);
|
|
if (!ddata->packet_running) {
|
|
pr_info("[haptic engine] motor run\n");
|
|
sec_vibrator_set_enable(ddata, true);
|
|
ddata->packet_running = true;
|
|
} else if (ddata->vib_ops->update_packet_params) {
|
|
pr_info("motor running, parameters update\n");
|
|
ddata->vib_ops->update_packet_params(ddata->dev);
|
|
}
|
|
} else {
|
|
ddata->vib_ops->set_fifo_intensity(ddata->dev, intensity);
|
|
ddata->packet_running = false;
|
|
sec_vibrator_set_enable(ddata, false);
|
|
ddata->vib_ops->enable_fifo(ddata->dev, file_num);
|
|
}
|
|
} else {
|
|
if (ddata->packet_running) {
|
|
pr_info("[haptic engine] motor stop\n");
|
|
sec_vibrator_set_enable(ddata, false);
|
|
}
|
|
ddata->packet_running = false;
|
|
sec_vibrator_set_intensity(ddata, intensity);
|
|
}
|
|
|
|
pr_info("%s end\n", __func__);
|
|
}
|
|
|
|
static void timed_output_enable(struct sec_vibrator_drvdata *ddata, unsigned int value)
|
|
{
|
|
struct hrtimer *timer = &ddata->timer;
|
|
int ret = 0;
|
|
|
|
if (!ddata) {
|
|
pr_err("%s : ddata is NULL\n", __func__);
|
|
return;
|
|
}
|
|
|
|
ret = hrtimer_cancel(timer);
|
|
kthread_flush_worker(&ddata->kworker);
|
|
|
|
mutex_lock(&ddata->vib_mutex);
|
|
|
|
value = min_t(int, value, MAX_TIMEOUT);
|
|
ddata->timeout = value;
|
|
|
|
if (value) {
|
|
if (ddata->f_packet_en) {
|
|
ddata->packet_running = false;
|
|
ddata->timeout = ddata->vib_pac[0].time;
|
|
sec_vibrator_engine_run_packet(ddata, ddata->vib_pac[0]);
|
|
} else {
|
|
sec_vibrator_haptic_enable(ddata);
|
|
}
|
|
|
|
if (!ddata->index)
|
|
hrtimer_start(timer, ns_to_ktime((u64)ddata->timeout * NSEC_PER_MSEC), HRTIMER_MODE_REL);
|
|
} else {
|
|
sec_vibrator_haptic_disable(ddata);
|
|
}
|
|
|
|
mutex_unlock(&ddata->vib_mutex);
|
|
}
|
|
|
|
static enum hrtimer_restart haptic_timer_func(struct hrtimer *timer)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata;
|
|
|
|
if (!timer) {
|
|
pr_err("%s : timer is NULL\n", __func__);
|
|
return -ENODATA;
|
|
}
|
|
|
|
ddata = container_of(timer, struct sec_vibrator_drvdata, timer);
|
|
|
|
if (!ddata) {
|
|
pr_err("%s : ddata is NULL\n", __func__);
|
|
return -ENODATA;
|
|
}
|
|
|
|
pr_info("%s\n", __func__);
|
|
kthread_queue_work(&ddata->kworker, &ddata->kwork);
|
|
return HRTIMER_NORESTART;
|
|
}
|
|
|
|
static void sec_vibrator_work(struct kthread_work *work)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata;
|
|
struct hrtimer *timer;
|
|
int fifo = 0;
|
|
|
|
if (!work) {
|
|
pr_err("%s : work is NULL\n", __func__);
|
|
return;
|
|
}
|
|
|
|
ddata = container_of(work, struct sec_vibrator_drvdata, kwork);
|
|
|
|
if (!ddata) {
|
|
pr_err("%s : ddata is NULL\n", __func__);
|
|
return;
|
|
}
|
|
|
|
timer = &ddata->timer;
|
|
|
|
if (!timer) {
|
|
pr_err("%s : timer is NULL\n", __func__);
|
|
return;
|
|
}
|
|
|
|
pr_info("%s\n", __func__);
|
|
mutex_lock(&ddata->vib_mutex);
|
|
|
|
if (ddata->f_packet_en) {
|
|
ddata->packet_cnt++;
|
|
if (ddata->packet_cnt < ddata->packet_size) {
|
|
ddata->timeout = ddata->vib_pac[ddata->packet_cnt].time;
|
|
fifo = ddata->vib_pac[ddata->packet_cnt].fifo_flag;
|
|
if (fifo == 0) {
|
|
sec_vibrator_engine_run_packet(ddata, ddata->vib_pac[ddata->packet_cnt]);
|
|
hrtimer_start(timer, ns_to_ktime((u64)ddata->timeout * NSEC_PER_MSEC),
|
|
HRTIMER_MODE_REL);
|
|
} else {
|
|
hrtimer_start(timer, ns_to_ktime((u64)ddata->timeout * NSEC_PER_MSEC),
|
|
HRTIMER_MODE_REL);
|
|
sec_vibrator_engine_run_packet(ddata, ddata->vib_pac[ddata->packet_cnt]);
|
|
}
|
|
goto unlock_without_vib_off;
|
|
} else {
|
|
ddata->f_packet_en = false;
|
|
ddata->packet_cnt = 0;
|
|
ddata->packet_size = 0;
|
|
}
|
|
}
|
|
|
|
sec_vibrator_haptic_disable(ddata);
|
|
|
|
unlock_without_vib_off:
|
|
mutex_unlock(&ddata->vib_mutex);
|
|
}
|
|
|
|
__visible_for_testing inline bool is_valid_params(struct device *dev, struct device_attribute *attr,
|
|
const char *buf, struct sec_vibrator_drvdata *ddata)
|
|
{
|
|
if (!dev) {
|
|
pr_err("%s : dev is NULL\n", __func__);
|
|
return false;
|
|
}
|
|
if (!attr) {
|
|
pr_err("%s : attr is NULL\n", __func__);
|
|
return false;
|
|
}
|
|
if (!buf) {
|
|
pr_err("%s : buf is NULL\n", __func__);
|
|
return false;
|
|
}
|
|
if (!ddata) {
|
|
pr_err("%s : ddata is NULL\n", __func__);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
__visible_for_testing ssize_t default_duty_store(struct device *dev, struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
int default_duty = 0, ret = 0;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
ret = kstrtoint(buf, 0, &default_duty);
|
|
if (ret) {
|
|
pr_err("%s : fail to get default_duty\n", __func__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
pr_info("%s %d\n", __func__, default_duty);
|
|
|
|
if ((default_duty < 0) || (default_duty > MAX_DUTY)) {
|
|
pr_err("[VIB]: %s out of range\n", __func__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (ddata->vib_ops->set_default_duty) {
|
|
ret = ddata->vib_ops->set_default_duty(ddata->dev, default_duty);
|
|
if (ret) {
|
|
pr_err("%s set_default_duty error : %d\n", __func__, ret);
|
|
goto err;
|
|
}
|
|
} else {
|
|
pr_info("%s this model doesn't need set_default_duty\n", __func__);
|
|
}
|
|
|
|
err:
|
|
return ret ? ret : count;
|
|
}
|
|
|
|
__visible_for_testing ssize_t default_duty_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
int ret = 0;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
if (!ddata->vib_ops->get_default_duty)
|
|
return snprintf(buf, VIB_BUFSIZE, "NONE\n");
|
|
|
|
ret = ddata->vib_ops->get_default_duty(ddata->dev, buf);
|
|
|
|
return ret;
|
|
}
|
|
|
|
__visible_for_testing ssize_t fold_open_duty_store(struct device *dev, struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
int fold_open_duty = 0, ret = 0;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
ret = kstrtoint(buf, 0, &fold_open_duty);
|
|
if (ret) {
|
|
pr_err("%s : fail to get fold_open_duty\n", __func__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
pr_info("%s %d\n", __func__, fold_open_duty);
|
|
|
|
if ((fold_open_duty < 0) || (fold_open_duty > MAX_DUTY)) {
|
|
pr_err("[VIB]: %s out of range\n", __func__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (ddata->vib_ops->set_fold_open_duty) {
|
|
ret = ddata->vib_ops->set_fold_open_duty(ddata->dev, fold_open_duty);
|
|
if (ret) {
|
|
pr_err("%s set_fold_open_duty error : %d\n", __func__, ret);
|
|
goto err;
|
|
}
|
|
} else {
|
|
pr_info("%s this model doesn't need set_fold_open_duty\n", __func__);
|
|
}
|
|
|
|
err:
|
|
return ret ? ret : count;
|
|
}
|
|
|
|
__visible_for_testing ssize_t fold_open_duty_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
int ret = 0;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
if (!ddata->vib_ops->get_fold_open_duty)
|
|
return snprintf(buf, VIB_BUFSIZE, "NONE\n");
|
|
|
|
ret = ddata->vib_ops->get_fold_open_duty(ddata->dev, buf);
|
|
|
|
return ret;
|
|
}
|
|
|
|
__visible_for_testing ssize_t fold_close_duty_store(struct device *dev, struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
int fold_close_duty = 0, ret = 0;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
ret = kstrtoint(buf, 0, &fold_close_duty);
|
|
if (ret) {
|
|
pr_err("%s : fail to get fold_close_duty\n", __func__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
pr_info("%s %d\n", __func__, fold_close_duty);
|
|
|
|
if ((fold_close_duty < 0) || (fold_close_duty > MAX_DUTY)) {
|
|
pr_err("[VIB]: %s out of range\n", __func__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (ddata->vib_ops->set_fold_close_duty) {
|
|
ret = ddata->vib_ops->set_fold_close_duty(ddata->dev, fold_close_duty);
|
|
if (ret) {
|
|
pr_err("%s set_fold_close_duty error : %d\n", __func__, ret);
|
|
goto err;
|
|
}
|
|
} else {
|
|
pr_info("%s this model doesn't need set_fold_close_duty\n", __func__);
|
|
}
|
|
|
|
err:
|
|
return ret ? ret : count;
|
|
}
|
|
|
|
__visible_for_testing ssize_t fold_close_duty_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
int ret = 0;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
if (!ddata->vib_ops->get_fold_close_duty)
|
|
return snprintf(buf, VIB_BUFSIZE, "NONE\n");
|
|
|
|
ret = ddata->vib_ops->get_fold_close_duty(ddata->dev, buf);
|
|
|
|
return ret;
|
|
}
|
|
|
|
__visible_for_testing ssize_t intensity_store(struct device *dev, struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
int intensity = 0, ret = 0;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
ret = kstrtoint(buf, 0, &intensity);
|
|
if (ret) {
|
|
pr_err("%s : fail to get intensity\n", __func__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
pr_info("%s %d\n", __func__, intensity);
|
|
|
|
if ((intensity < 0) || (intensity > MAX_INTENSITY)) {
|
|
pr_err("[VIB]: %s out of range\n", __func__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
ddata->intensity = intensity;
|
|
|
|
return count;
|
|
}
|
|
|
|
__visible_for_testing ssize_t intensity_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
return snprintf(buf, VIB_BUFSIZE, "intensity: %u\n", ddata->intensity);
|
|
}
|
|
|
|
static ssize_t fifo_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = (struct sec_vibrator_drvdata *) dev_get_drvdata(dev);
|
|
int ret;
|
|
int file_num;
|
|
|
|
pr_info("%s +\n", __func__);
|
|
|
|
ret = kstrtoint(buf, 0, &file_num);
|
|
if (ret) {
|
|
pr_err("fail to get file_num\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (!ddata->vib_ops->enable_fifo || !ddata->vib_ops->set_fifo_intensity) {
|
|
pr_err("fifo functionality doesn't support\n");
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
ret = ddata->vib_ops->set_fifo_intensity(ddata->dev, 10000);
|
|
ret = ddata->vib_ops->enable_fifo(ddata->dev, file_num);
|
|
|
|
pr_info("%s -\n", __func__);
|
|
return count;
|
|
}
|
|
|
|
static ssize_t fifo_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = (struct sec_vibrator_drvdata *)
|
|
dev_get_drvdata(dev);
|
|
int ret = 0;
|
|
|
|
if (!ddata->vib_ops->get_fifo_filepath)
|
|
return snprintf(buf, VIB_BUFSIZE, "NONE\n");
|
|
|
|
ret = ddata->vib_ops->get_fifo_filepath(ddata->dev, buf);
|
|
|
|
return ret;
|
|
}
|
|
|
|
__visible_for_testing ssize_t multi_freq_store(struct device *dev, struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
int num, ret;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
ret = kstrtoint(buf, 0, &num);
|
|
if (ret) {
|
|
pr_err("fail to get frequency\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
pr_info("%s %d\n", __func__, num);
|
|
|
|
ddata->frequency = num;
|
|
|
|
return count;
|
|
}
|
|
|
|
__visible_for_testing ssize_t multi_freq_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
return snprintf(buf, VIB_BUFSIZE, "frequency: %d\n", ddata->frequency);
|
|
}
|
|
|
|
// TODO: need to update
|
|
__visible_for_testing ssize_t haptic_engine_store(struct device *dev, struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
int index = 0, _data = 0, tmp = 0;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
if (sscanf(buf, "%6d", &_data) != 1)
|
|
return count;
|
|
|
|
if (_data > PACKET_MAX_SIZE * VIB_PACKET_MAX) {
|
|
pr_info("%s, [%d] packet size over\n", __func__, _data);
|
|
return count;
|
|
}
|
|
ddata->packet_size = _data / VIB_PACKET_MAX;
|
|
ddata->packet_cnt = 0;
|
|
ddata->f_packet_en = true;
|
|
buf = strstr(buf, " ");
|
|
|
|
for (index = 0; index < ddata->packet_size; index++) {
|
|
for (tmp = 0; tmp < VIB_PACKET_MAX; tmp++) {
|
|
if (buf == NULL) {
|
|
pr_err("%s, buf is NULL, Please check packet data again\n", __func__);
|
|
ddata->f_packet_en = false;
|
|
return count;
|
|
}
|
|
|
|
if (sscanf(buf++, "%6d", &_data) != 1) {
|
|
pr_err("%s, packet data error, Please check packet data again\n", __func__);
|
|
ddata->f_packet_en = false;
|
|
return count;
|
|
}
|
|
|
|
switch (tmp) {
|
|
case VIB_PACKET_TIME:
|
|
ddata->vib_pac[index].time = _data;
|
|
break;
|
|
case VIB_PACKET_INTENSITY:
|
|
ddata->vib_pac[index].intensity = _data;
|
|
break;
|
|
case VIB_PACKET_FREQUENCY:
|
|
ddata->vib_pac[index].freq = _data;
|
|
break;
|
|
case VIB_PACKET_OVERDRIVE:
|
|
ddata->vib_pac[index].overdrive = _data;
|
|
break;
|
|
}
|
|
buf = strstr(buf, " ");
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
__visible_for_testing ssize_t haptic_engine_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
int index = 0;
|
|
size_t size = 0;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
for (index = 0; index < ddata->packet_size && ddata->f_packet_en &&
|
|
((4 * VIB_BUFSIZE + size) < PAGE_SIZE); index++) {
|
|
size += snprintf(&buf[size], VIB_BUFSIZE, "%u,", ddata->vib_pac[index].time);
|
|
size += snprintf(&buf[size], VIB_BUFSIZE, "%u,", ddata->vib_pac[index].intensity);
|
|
size += snprintf(&buf[size], VIB_BUFSIZE, "%u,", ddata->vib_pac[index].freq);
|
|
size += snprintf(&buf[size], VIB_BUFSIZE, "%u,", ddata->vib_pac[index].overdrive);
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
static ssize_t hybrid_haptic_engine_store(struct device *dev,
|
|
struct device_attribute *devattr, const char *buf, size_t count)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = (struct sec_vibrator_drvdata *)
|
|
dev_get_drvdata(dev);
|
|
int i = 0, _data = 0, tmp = 0, check_fifo = 0, origin_time = 0;
|
|
int way1_cmp_sum = 0, way2_cmp_sum = 0;
|
|
int normal_pac_time_sum = 0;
|
|
int compensation_way = VIB_NO_COMPEMSATION;
|
|
|
|
pr_info("%s +\n", __func__);
|
|
if (sscanf(buf, "%6d", &_data) != 1)
|
|
return count;
|
|
|
|
if (_data > PACKET_MAX_SIZE * VIB_PACKET_MAX)
|
|
pr_info("%s, [%d] packet size over\n", __func__, _data);
|
|
else {
|
|
ddata->packet_size = _data / VIB_PACKET_MAX;
|
|
ddata->packet_cnt = 0;
|
|
ddata->f_packet_en = true;
|
|
|
|
buf = strstr(buf, " ");
|
|
|
|
for (i = 0; i < ddata->packet_size; i++) {
|
|
check_fifo = 0;
|
|
for (tmp = 0; tmp < VIB_PACKET_MAX; tmp++) {
|
|
if (buf == NULL) {
|
|
pr_err("%s, buf is NULL, Please check packet data again\n",
|
|
__func__);
|
|
ddata->f_packet_en = false;
|
|
return count;
|
|
}
|
|
|
|
if (*(buf+1) == '#') {
|
|
buf = buf+2;
|
|
if ((*buf != '\0') && (sscanf(buf++, "%6d", &_data) == 1))
|
|
check_fifo = 1;
|
|
}
|
|
|
|
else if (sscanf(buf++, "%6d", &_data) != 1) {
|
|
pr_err("%s, packet data error, Please check packet data again\n",
|
|
__func__);
|
|
ddata->f_packet_en = false;
|
|
return count;
|
|
}
|
|
|
|
switch (tmp) {
|
|
case VIB_PACKET_TIME:
|
|
ddata->vib_pac[i].time = _data;
|
|
break;
|
|
case VIB_PACKET_INTENSITY:
|
|
ddata->vib_pac[i].intensity = _data;
|
|
break;
|
|
case VIB_PACKET_FREQUENCY:
|
|
ddata->vib_pac[i].freq = _data;
|
|
if (check_fifo == 0) {
|
|
ddata->vib_pac[i].fifo_flag = 0;
|
|
if (ddata->time_compensation && ddata->max_delay_ms) {
|
|
origin_time = ddata->vib_pac[i].time;
|
|
normal_pac_time_sum += origin_time;
|
|
way1_cmp_sum += (origin_time*ddata->time_compensation)/100;
|
|
way2_cmp_sum += ddata->max_delay_ms;
|
|
}
|
|
} else
|
|
ddata->vib_pac[i].fifo_flag = 1;
|
|
break;
|
|
case VIB_PACKET_OVERDRIVE:
|
|
ddata->vib_pac[i].overdrive = _data;
|
|
break;
|
|
}
|
|
buf = strstr(buf, " ");
|
|
}
|
|
}
|
|
|
|
if (ddata->time_compensation == 0 || way2_cmp_sum <= ddata->max_delay_ms) {
|
|
compensation_way = VIB_NO_COMPEMSATION;
|
|
} else if (way1_cmp_sum < way2_cmp_sum) {
|
|
compensation_way = VIB_COMPENSATION_WAY1;
|
|
pr_info("%s compensation way1:way1_cmp_sum=%d\n",
|
|
__func__, way1_cmp_sum);
|
|
} else {
|
|
compensation_way = VIB_COMPENSATION_WAY2;
|
|
pr_info("%s compensation way2:way2_cmp_sum=%d,normal_pac_time_sum=%d\n",
|
|
__func__, way2_cmp_sum, normal_pac_time_sum);
|
|
}
|
|
|
|
for (i = 0; i < ddata->packet_size; i++) {
|
|
if (ddata->vib_pac[i].fifo_flag == 1) {
|
|
pr_info("%s i=%d, file=%d time=%d intensity=%d\n", __func__, i,
|
|
ddata->vib_pac[i].freq,
|
|
ddata->vib_pac[i].time,
|
|
ddata->vib_pac[i].intensity);
|
|
continue;
|
|
}
|
|
origin_time = ddata->vib_pac[i].time;
|
|
if (compensation_way == VIB_COMPENSATION_WAY1)
|
|
ddata->vib_pac[i].time -= (origin_time*ddata->time_compensation)/100;
|
|
else if (compensation_way == VIB_COMPENSATION_WAY2 && normal_pac_time_sum != 0)
|
|
ddata->vib_pac[i].time -= (way2_cmp_sum*origin_time)/normal_pac_time_sum;
|
|
|
|
pr_info("%s i=%d, origin_time=%d->time=%d intensity=%d freq=%d\n",
|
|
__func__, i, origin_time,
|
|
ddata->vib_pac[i].time,
|
|
ddata->vib_pac[i].intensity,
|
|
ddata->vib_pac[i].freq);
|
|
}
|
|
}
|
|
pr_info("%s -\n", __func__);
|
|
return count;
|
|
}
|
|
|
|
static ssize_t hybrid_haptic_engine_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = (struct sec_vibrator_drvdata *)
|
|
dev_get_drvdata(dev);
|
|
int i = 0;
|
|
size_t size = 0;
|
|
|
|
for (i = 0; i < ddata->packet_size && ddata->f_packet_en &&
|
|
((4 * VIB_BUFSIZE + size) < PAGE_SIZE); i++) {
|
|
size += snprintf(&buf[size], VIB_BUFSIZE, "%u,", ddata->vib_pac[i].time);
|
|
size += snprintf(&buf[size], VIB_BUFSIZE, "%u,", ddata->vib_pac[i].intensity);
|
|
size += snprintf(&buf[size], VIB_BUFSIZE, "%u,", ddata->vib_pac[i].freq);
|
|
size += snprintf(&buf[size], VIB_BUFSIZE, "%u,", ddata->vib_pac[i].overdrive);
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
__visible_for_testing ssize_t cp_trigger_index_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
int ret = 0;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
if (!ddata->vib_ops->get_cp_trigger_index)
|
|
return -ENOSYS;
|
|
|
|
ret = ddata->vib_ops->get_cp_trigger_index(ddata->dev, buf);
|
|
|
|
return ret;
|
|
}
|
|
|
|
__visible_for_testing ssize_t cp_trigger_index_store(struct device *dev, struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
int ret = 0;
|
|
unsigned int index;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
if (!ddata->vib_ops->set_cp_trigger_index)
|
|
return -ENOSYS;
|
|
|
|
ret = kstrtou32(buf, 10, &index);
|
|
if (ret)
|
|
return -EINVAL;
|
|
|
|
ddata->index = index;
|
|
|
|
ret = ddata->vib_ops->set_cp_trigger_index(ddata->dev, buf);
|
|
if (ret < 0)
|
|
pr_err("%s error(%d)\n", __func__, ret);
|
|
|
|
return count;
|
|
}
|
|
|
|
__visible_for_testing ssize_t cp_trigger_queue_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
int ret = 0;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
if (!ddata->vib_ops->get_cp_trigger_queue)
|
|
return -ENOSYS;
|
|
|
|
ret = ddata->vib_ops->get_cp_trigger_queue(ddata->dev, buf);
|
|
if (ret < 0)
|
|
pr_err("%s error(%d)\n", __func__, ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
__visible_for_testing ssize_t cp_trigger_queue_store(struct device *dev, struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
int ret = 0;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
if (!ddata->vib_ops->set_cp_trigger_queue)
|
|
return -ENOSYS;
|
|
|
|
ret = ddata->vib_ops->set_cp_trigger_queue(ddata->dev, buf);
|
|
if (ret < 0)
|
|
pr_err("%s error(%d)\n", __func__, ret);
|
|
|
|
return count;
|
|
}
|
|
|
|
__visible_for_testing ssize_t pwle_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
int ret = 0;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
if (!ddata->vib_ops->get_pwle)
|
|
return -ENOSYS;
|
|
|
|
ret = ddata->vib_ops->get_pwle(ddata->dev, buf);
|
|
if (ret < 0)
|
|
pr_err("%s error(%d)\n", __func__, ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
__visible_for_testing ssize_t pwle_store(struct device *dev, struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
int ret = 0;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
if (!ddata->vib_ops->set_pwle)
|
|
return -ENOSYS;
|
|
|
|
ret = ddata->vib_ops->set_pwle(ddata->dev, buf);
|
|
if (ret < 0)
|
|
pr_err("%s error(%d)\n", __func__, ret);
|
|
|
|
return count;
|
|
}
|
|
|
|
__visible_for_testing ssize_t virtual_composite_indexes_show(struct device *dev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
int ret = 0;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
if (!ddata->vib_ops->get_virtual_composite_indexes)
|
|
return -ENOSYS;
|
|
|
|
ret = ddata->vib_ops->get_virtual_composite_indexes(ddata->dev, buf);
|
|
if (ret < 0)
|
|
pr_err("%s error(%d)\n", __func__, ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
__visible_for_testing ssize_t virtual_pwle_indexes_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
int ret = 0;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
if (!ddata->vib_ops->get_virtual_pwle_indexes)
|
|
return -ENOSYS;
|
|
|
|
ret = ddata->vib_ops->get_virtual_pwle_indexes(ddata->dev, buf);
|
|
if (ret < 0)
|
|
pr_err("%s error(%d)\n", __func__, ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
__visible_for_testing ssize_t enable_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
struct hrtimer *timer = &ddata->timer;
|
|
int remaining = 0;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
if (hrtimer_active(timer)) {
|
|
ktime_t remain = hrtimer_get_remaining(timer);
|
|
struct timespec64 t = ns_to_timespec64(remain);
|
|
|
|
remaining = t.tv_sec * 1000 + t.tv_nsec / 1000;
|
|
}
|
|
return sprintf(buf, "%d\n", remaining);
|
|
}
|
|
|
|
__visible_for_testing ssize_t enable_store(struct device *dev, struct device_attribute *attr,
|
|
const char *buf, size_t size)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
int value;
|
|
int ret;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
ret = kstrtoint(buf, 0, &value);
|
|
if (ret != 0)
|
|
return -EINVAL;
|
|
|
|
timed_output_enable(ddata, value);
|
|
return size;
|
|
}
|
|
|
|
__visible_for_testing ssize_t motor_type_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
int ret = 0;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
if (!ddata->vib_ops->get_motor_type)
|
|
return snprintf(buf, VIB_BUFSIZE, "NONE\n");
|
|
|
|
ret = ddata->vib_ops->get_motor_type(ddata->dev, buf);
|
|
|
|
return ret;
|
|
}
|
|
|
|
__visible_for_testing ssize_t use_sep_index_store(struct device *dev, struct device_attribute *attr,
|
|
const char *buf, size_t size)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
int ret = 0;
|
|
bool use_sep_index;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
ret = kstrtobool(buf, &use_sep_index);
|
|
if (ret < 0) {
|
|
pr_err("%s kstrtobool error : %d\n", __func__, ret);
|
|
goto err;
|
|
}
|
|
|
|
pr_info("%s use_sep_index:%d\n", __func__, use_sep_index);
|
|
|
|
if (ddata->vib_ops->set_use_sep_index) {
|
|
ret = ddata->vib_ops->set_use_sep_index(ddata->dev, use_sep_index);
|
|
if (ret) {
|
|
pr_err("%s set_use_sep_index error : %d\n", __func__, ret);
|
|
goto err;
|
|
}
|
|
} else {
|
|
pr_info("%s this model doesn't need use_sep_index\n", __func__);
|
|
}
|
|
err:
|
|
return ret ? ret : size;
|
|
}
|
|
|
|
int sec_vibrator_recheck_ratio(struct sec_vibrator_drvdata *ddata)
|
|
{
|
|
int temp = ddata->temperature;
|
|
|
|
if (temp >= ddata->pdata->high_temp_ref)
|
|
return ddata->pdata->high_temp_ratio;
|
|
|
|
return ddata->pdata->normal_ratio;
|
|
}
|
|
EXPORT_SYMBOL_GPL(sec_vibrator_recheck_ratio);
|
|
|
|
__visible_for_testing ssize_t current_temp_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
return sprintf(buf, "%d\n", ddata->temperature);
|
|
}
|
|
|
|
__visible_for_testing ssize_t current_temp_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t count)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
int temp, ret = 0;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
ret = kstrtos32(buf, 0, &temp);
|
|
if (ret < 0) {
|
|
pr_err("%s kstrtos32 error : %d\n", __func__, ret);
|
|
ddata->temperature = INT_MIN;
|
|
goto err;
|
|
}
|
|
|
|
ddata->temperature = temp;
|
|
pr_info("%s temperature : %d\n", __func__, ddata->temperature);
|
|
err:
|
|
return ret ? ret : count;
|
|
}
|
|
|
|
__visible_for_testing ssize_t num_waves_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
int ret = 0;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
if (!ddata->vib_ops->get_num_waves)
|
|
return -ENOSYS;
|
|
|
|
ret = ddata->vib_ops->get_num_waves(ddata->dev, buf);
|
|
|
|
return ret;
|
|
}
|
|
|
|
__visible_for_testing ssize_t array2str(char *buf, int *arr_intensity, int size)
|
|
{
|
|
int index, ret = 0;
|
|
char *str_buf = NULL;
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
|
|
if (!buf || !ddata)
|
|
return -ENODATA;
|
|
|
|
if (!arr_intensity || ((size < 1) && (size > kMaxHapticStepSize)))
|
|
return -EINVAL;
|
|
|
|
str_buf = kzalloc(kMaxBufSize, GFP_KERNEL);
|
|
if (!str_buf)
|
|
return -ENOMEM;
|
|
|
|
mutex_lock(&ddata->vib_mutex);
|
|
for (index = 0; index < size; index++) {
|
|
if (index < (size - 1))
|
|
snprintf(str_buf, kMaxBufSize, "%u,", arr_intensity[index]);
|
|
else
|
|
snprintf(str_buf, (kMaxBufSize - 1), "%u", arr_intensity[index]);
|
|
strncat(buf, str_buf, strlen(str_buf));
|
|
}
|
|
strncat(buf, str_newline, strlen(str_newline));
|
|
ret = strlen(buf);
|
|
mutex_unlock(&ddata->vib_mutex);
|
|
|
|
kfree(str_buf);
|
|
return ret;
|
|
}
|
|
|
|
__visible_for_testing ssize_t intensities_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
int *arr_intensity = NULL;
|
|
int ret = 0, step_size = 0;
|
|
|
|
pr_info("%s\n", __func__);
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
if (!ddata->vib_ops->get_step_size || !ddata->vib_ops->get_intensities)
|
|
return -EOPNOTSUPP;
|
|
|
|
ret = ddata->vib_ops->get_step_size(ddata->dev, &step_size);
|
|
if (ret)
|
|
return -EINVAL;
|
|
|
|
arr_intensity = kmalloc_array(kMaxHapticStepSize, sizeof(int), GFP_KERNEL);
|
|
if (!arr_intensity)
|
|
return -ENOMEM;
|
|
|
|
if ((step_size > 0) && (step_size < kMaxHapticStepSize)) {
|
|
ret = ddata->vib_ops->get_intensities(ddata->dev, arr_intensity);
|
|
if (ret) {
|
|
ret = -EINVAL;
|
|
goto err_arr_alloc;
|
|
}
|
|
ret = array2str(buf, arr_intensity, step_size);
|
|
} else {
|
|
ret = -EINVAL;
|
|
}
|
|
|
|
err_arr_alloc:
|
|
kfree(arr_intensity);
|
|
return ret;
|
|
}
|
|
|
|
__visible_for_testing ssize_t haptic_intensities_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
int *arr_intensity = NULL;
|
|
int ret = 0, step_size = 0;
|
|
|
|
pr_info("%s\n", __func__);
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
if (!ddata->vib_ops->get_step_size || !ddata->vib_ops->get_haptic_intensities)
|
|
return -EOPNOTSUPP;
|
|
|
|
ret = ddata->vib_ops->get_step_size(ddata->dev, &step_size);
|
|
if (ret)
|
|
return -EINVAL;
|
|
|
|
arr_intensity = kmalloc_array(kMaxHapticStepSize, sizeof(int), GFP_KERNEL);
|
|
if (!arr_intensity)
|
|
return -ENOMEM;
|
|
|
|
if ((step_size > 0) && (step_size < kMaxHapticStepSize)) {
|
|
ret = ddata->vib_ops->get_haptic_intensities(ddata->dev, arr_intensity);
|
|
if (ret) {
|
|
ret = -EINVAL;
|
|
goto err_arr_alloc;
|
|
}
|
|
ret = array2str(buf, arr_intensity, step_size);
|
|
} else {
|
|
ret = -EINVAL;
|
|
}
|
|
|
|
err_arr_alloc:
|
|
kfree(arr_intensity);
|
|
return ret;
|
|
}
|
|
|
|
__visible_for_testing ssize_t haptic_durations_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
int *arr_duration = NULL;
|
|
int ret = 0, step_size = 0;
|
|
|
|
pr_info("%s\n", __func__);
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
if (!ddata->vib_ops->get_step_size || !ddata->vib_ops->get_haptic_durations)
|
|
return -EOPNOTSUPP;
|
|
|
|
ret = ddata->vib_ops->get_step_size(ddata->dev, &step_size);
|
|
if (ret)
|
|
return -EINVAL;
|
|
|
|
arr_duration = kmalloc_array(kMaxHapticStepSize, sizeof(int), GFP_KERNEL);
|
|
if (!arr_duration)
|
|
return -ENOMEM;
|
|
|
|
if ((step_size > 0) && (step_size < kMaxHapticStepSize)) {
|
|
ret = ddata->vib_ops->get_haptic_durations(ddata->dev, arr_duration);
|
|
if (ret) {
|
|
ret = -EINVAL;
|
|
goto err_arr_alloc;
|
|
}
|
|
ret = array2str(buf, arr_duration, step_size);
|
|
} else {
|
|
ret = -EINVAL;
|
|
}
|
|
|
|
err_arr_alloc:
|
|
kfree(arr_duration);
|
|
return ret;
|
|
}
|
|
|
|
__visible_for_testing int get_event_index_by_command(char *cur_cmd)
|
|
{
|
|
int cmd_idx;
|
|
|
|
for (cmd_idx = 0; cmd_idx < EVENT_CMD_MAX; cmd_idx++) {
|
|
if (!strcmp(cur_cmd, sec_vib_event_cmd[cmd_idx]))
|
|
return cmd_idx;
|
|
}
|
|
|
|
return EVENT_CMD_NONE;
|
|
}
|
|
|
|
__visible_for_testing ssize_t event_cmd_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
|
|
pr_info("%s event: %s\n", __func__, vib_event_cmd);
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
return snprintf(buf, MAX_STR_LEN_EVENT_CMD, "%s\n", vib_event_cmd);
|
|
}
|
|
|
|
__visible_for_testing ssize_t event_cmd_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t count)
|
|
{
|
|
struct sec_vibrator_drvdata *ddata = g_ddata;
|
|
char *cmd;
|
|
int ret = 0;
|
|
int event_idx;
|
|
|
|
if (!is_valid_params(dev, attr, buf, ddata))
|
|
return -ENODATA;
|
|
|
|
if (!ddata->vib_ops->set_event_cmd)
|
|
return -ENOSYS;
|
|
|
|
if (count >= MAX_STR_LEN_EVENT_CMD) {
|
|
pr_err("%s: size(%zu) is too long.\n", __func__, count);
|
|
goto error;
|
|
}
|
|
|
|
cmd = kzalloc(count + 1, GFP_KERNEL);
|
|
if (!cmd)
|
|
goto error;
|
|
|
|
ret = sscanf(buf, "%s", cmd);
|
|
if (ret != 1)
|
|
goto error1;
|
|
|
|
event_idx = get_event_index_by_command(cmd);
|
|
|
|
pr_info("%s: event: %s(%d)\n", __func__, cmd, event_idx);
|
|
|
|
ret = ddata->vib_ops->set_event_cmd(ddata->dev, event_idx);
|
|
if (ret)
|
|
pr_err("%s error(%d)\n", __func__, ret);
|
|
|
|
sscanf(cmd, "%s", vib_event_cmd);
|
|
|
|
error1:
|
|
kfree(cmd);
|
|
error:
|
|
return count;
|
|
}
|
|
|
|
static DEVICE_ATTR_RW(haptic_engine);
|
|
static DEVICE_ATTR_RW(multi_freq);
|
|
static DEVICE_ATTR_RW(intensity);
|
|
static DEVICE_ATTR_RW(cp_trigger_index);
|
|
static DEVICE_ATTR_RW(cp_trigger_queue);
|
|
static DEVICE_ATTR_RW(pwle);
|
|
static DEVICE_ATTR_RO(virtual_composite_indexes);
|
|
static DEVICE_ATTR_RO(virtual_pwle_indexes);
|
|
static DEVICE_ATTR_RW(enable);
|
|
static DEVICE_ATTR_RW(default_duty);
|
|
static DEVICE_ATTR_RW(fold_open_duty);
|
|
static DEVICE_ATTR_RW(fold_close_duty);
|
|
static DEVICE_ATTR_RO(motor_type);
|
|
static DEVICE_ATTR_WO(use_sep_index);
|
|
static DEVICE_ATTR_RW(current_temp);
|
|
static DEVICE_ATTR_RW(fifo);
|
|
static DEVICE_ATTR_RW(hybrid_haptic_engine);
|
|
static DEVICE_ATTR_RO(num_waves);
|
|
static DEVICE_ATTR_RO(intensities);
|
|
static DEVICE_ATTR_RO(haptic_intensities);
|
|
static DEVICE_ATTR_RO(haptic_durations);
|
|
static DEVICE_ATTR_RW(event_cmd);
|
|
|
|
static struct attribute *sec_vibrator_attributes[] = {
|
|
&dev_attr_enable.attr,
|
|
&dev_attr_default_duty.attr,
|
|
&dev_attr_fold_open_duty.attr,
|
|
&dev_attr_fold_close_duty.attr,
|
|
&dev_attr_motor_type.attr,
|
|
&dev_attr_use_sep_index.attr,
|
|
&dev_attr_current_temp.attr,
|
|
&dev_attr_fifo.attr,
|
|
&dev_attr_hybrid_haptic_engine.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute_group sec_vibrator_attr_group = {
|
|
.attrs = sec_vibrator_attributes,
|
|
};
|
|
|
|
static struct attribute *multi_freq_attributes[] = {
|
|
&dev_attr_haptic_engine.attr,
|
|
&dev_attr_multi_freq.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute_group multi_freq_attr_group = {
|
|
.attrs = multi_freq_attributes,
|
|
};
|
|
|
|
static struct attribute *cp_trigger_attributes[] = {
|
|
&dev_attr_haptic_engine.attr,
|
|
&dev_attr_num_waves.attr,
|
|
&dev_attr_cp_trigger_index.attr,
|
|
&dev_attr_cp_trigger_queue.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute_group cp_trigger_attr_group = {
|
|
.attrs = cp_trigger_attributes,
|
|
};
|
|
|
|
static struct attribute *pwle_attributes[] = {
|
|
&dev_attr_pwle.attr,
|
|
&dev_attr_virtual_composite_indexes.attr,
|
|
&dev_attr_virtual_pwle_indexes.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute_group pwle_attr_group = {
|
|
.attrs = pwle_attributes,
|
|
};
|
|
|
|
int sec_vibrator_register(struct sec_vibrator_drvdata *ddata)
|
|
{
|
|
struct task_struct *kworker_task;
|
|
int ret = 0;
|
|
|
|
if (!ddata) {
|
|
pr_err("%s no ddata\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
|
|
g_ddata = ddata;
|
|
|
|
mutex_init(&ddata->vib_mutex);
|
|
kthread_init_worker(&ddata->kworker);
|
|
kworker_task = kthread_run(kthread_worker_fn, &ddata->kworker, "sec_vibrator");
|
|
|
|
if (IS_ERR(kworker_task)) {
|
|
pr_err("Failed to create message pump task\n");
|
|
ret = -ENOMEM;
|
|
goto err_kthread;
|
|
}
|
|
|
|
kthread_init_work(&ddata->kwork, sec_vibrator_work);
|
|
hrtimer_init(&ddata->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
|
|
ddata->timer.function = haptic_timer_func;
|
|
|
|
/* create /sys/class/timed_output/vibrator */
|
|
ddata->to_class = class_create(THIS_MODULE, "timed_output");
|
|
if (IS_ERR(ddata->to_class)) {
|
|
ret = PTR_ERR(ddata->to_class);
|
|
goto err_class_create;
|
|
}
|
|
ddata->to_dev = device_create(ddata->to_class, NULL, MKDEV(0, 0), ddata, "vibrator");
|
|
if (IS_ERR(ddata->to_dev)) {
|
|
ret = PTR_ERR(ddata->to_dev);
|
|
goto err_device_create;
|
|
}
|
|
|
|
ret = sysfs_create_group(&ddata->to_dev->kobj, &sec_vibrator_attr_group);
|
|
if (ret) {
|
|
ret = -ENODEV;
|
|
pr_err("Failed to create sysfs1 %d\n", ret);
|
|
goto err_sysfs1;
|
|
}
|
|
|
|
if (ddata->vib_ops->set_intensity) {
|
|
ret = sysfs_create_file(&ddata->to_dev->kobj, &dev_attr_intensity.attr);
|
|
if (ret) {
|
|
ret = -ENODEV;
|
|
pr_err("Failed to create sysfs2 %d\n", ret);
|
|
goto err_sysfs2;
|
|
}
|
|
|
|
ddata->intensity = MAX_INTENSITY;
|
|
}
|
|
|
|
if (ddata->vib_ops->set_frequency) {
|
|
ret = sysfs_create_group(&ddata->to_dev->kobj, &multi_freq_attr_group);
|
|
if (ret) {
|
|
ret = -ENODEV;
|
|
pr_err("Failed to create sysfs3 %d\n", ret);
|
|
goto err_sysfs3;
|
|
}
|
|
|
|
ddata->frequency = FREQ_ALERT;
|
|
}
|
|
|
|
if (ddata->vib_ops->set_cp_trigger_index) {
|
|
ret = sysfs_create_group(&ddata->to_dev->kobj, &cp_trigger_attr_group);
|
|
if (ret) {
|
|
ret = -ENODEV;
|
|
pr_err("Failed to create sysfs4 %d\n", ret);
|
|
goto err_sysfs4;
|
|
}
|
|
|
|
}
|
|
|
|
if (ddata->vib_ops->set_pwle) {
|
|
ret = sysfs_create_group(&ddata->to_dev->kobj, &pwle_attr_group);
|
|
if (ret) {
|
|
ret = -ENODEV;
|
|
pr_err("Failed to create sysfs5 %d\n", ret);
|
|
goto err_sysfs5;
|
|
}
|
|
|
|
}
|
|
|
|
if (ddata->vib_ops->set_event_cmd) {
|
|
/* initialize event_cmd string for HAL init */
|
|
sscanf(ddata->event_cmd, "%s", vib_event_cmd);
|
|
pr_info("%s: vib_event_cmd: %s\n", __func__, vib_event_cmd);
|
|
|
|
ret = sysfs_create_file(&ddata->to_dev->kobj, &dev_attr_event_cmd.attr);
|
|
if (ret) {
|
|
ret = -ENODEV;
|
|
pr_err("Failed to create sysfs6 %d\n", ret);
|
|
goto err_sysfs6;
|
|
}
|
|
}
|
|
|
|
if (ddata->vib_ops->get_calibration && ddata->vib_ops->get_calibration(ddata->dev)) {
|
|
if (ddata->vib_ops->get_intensities) {
|
|
ret = sysfs_create_file(&ddata->to_dev->kobj, &dev_attr_intensities.attr);
|
|
if (ret) {
|
|
ret = -ENODEV;
|
|
pr_err("Failed to create intensities %d\n", ret);
|
|
goto err_cal1;
|
|
}
|
|
}
|
|
|
|
if (ddata->vib_ops->get_haptic_intensities) {
|
|
ret = sysfs_create_file(&ddata->to_dev->kobj, &dev_attr_haptic_intensities.attr);
|
|
if (ret) {
|
|
ret = -ENODEV;
|
|
pr_err("Failed to create haptic_intensities %d\n", ret);
|
|
goto err_cal2;
|
|
}
|
|
}
|
|
|
|
if (ddata->vib_ops->get_haptic_durations) {
|
|
ret = sysfs_create_file(&ddata->to_dev->kobj, &dev_attr_haptic_durations.attr);
|
|
if (ret) {
|
|
ret = -ENODEV;
|
|
pr_err("Failed to create haptic_intensities %d\n", ret);
|
|
goto err_cal3;
|
|
}
|
|
}
|
|
}
|
|
|
|
ddata->pdata = &sec_vibrator_pdata;
|
|
|
|
pr_info("%s done\n", __func__);
|
|
|
|
ddata->is_registered = true;
|
|
|
|
return ret;
|
|
|
|
err_cal3:
|
|
if (ddata->vib_ops->get_calibration && ddata->vib_ops->get_calibration(ddata->dev)) {
|
|
if (ddata->vib_ops->get_haptic_intensities)
|
|
sysfs_remove_file(&ddata->to_dev->kobj, &dev_attr_haptic_intensities.attr);
|
|
}
|
|
err_cal2:
|
|
if (ddata->vib_ops->get_calibration && ddata->vib_ops->get_calibration(ddata->dev)) {
|
|
if (ddata->vib_ops->get_intensities)
|
|
sysfs_remove_file(&ddata->to_dev->kobj, &dev_attr_intensities.attr);
|
|
}
|
|
err_cal1:
|
|
if (ddata->vib_ops->set_event_cmd)
|
|
sysfs_remove_file(&ddata->to_dev->kobj, &dev_attr_event_cmd.attr);
|
|
err_sysfs6:
|
|
if (ddata->vib_ops->set_pwle)
|
|
sysfs_remove_group(&ddata->to_dev->kobj, &pwle_attr_group);
|
|
err_sysfs5:
|
|
if (ddata->vib_ops->set_cp_trigger_index)
|
|
sysfs_remove_group(&ddata->to_dev->kobj, &cp_trigger_attr_group);
|
|
err_sysfs4:
|
|
if (ddata->vib_ops->set_frequency)
|
|
sysfs_remove_group(&ddata->to_dev->kobj, &multi_freq_attr_group);
|
|
err_sysfs3:
|
|
if (ddata->vib_ops->set_intensity)
|
|
sysfs_remove_file(&ddata->to_dev->kobj, &dev_attr_intensity.attr);
|
|
err_sysfs2:
|
|
sysfs_remove_group(&ddata->to_dev->kobj, &sec_vibrator_attr_group);
|
|
err_sysfs1:
|
|
device_destroy(ddata->to_class, MKDEV(0, 0));
|
|
err_device_create:
|
|
class_destroy(ddata->to_class);
|
|
err_class_create:
|
|
err_kthread:
|
|
mutex_destroy(&ddata->vib_mutex);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(sec_vibrator_register);
|
|
|
|
int sec_vibrator_unregister(struct sec_vibrator_drvdata *ddata)
|
|
{
|
|
if (!ddata || !ddata->is_registered) {
|
|
pr_info("%s: sec_vibrator not registered, just return\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
|
|
sec_vibrator_haptic_disable(ddata);
|
|
g_ddata = NULL;
|
|
|
|
if (ddata->vib_ops->get_calibration && ddata->vib_ops->get_calibration(ddata->dev)) {
|
|
if (ddata->vib_ops->get_haptic_intensities)
|
|
sysfs_remove_file(&ddata->to_dev->kobj, &dev_attr_haptic_intensities.attr);
|
|
if (ddata->vib_ops->get_intensities)
|
|
sysfs_remove_file(&ddata->to_dev->kobj, &dev_attr_intensities.attr);
|
|
}
|
|
if (ddata->vib_ops->set_event_cmd)
|
|
sysfs_remove_file(&ddata->to_dev->kobj, &dev_attr_event_cmd.attr);
|
|
if (ddata->vib_ops->set_pwle)
|
|
sysfs_remove_group(&ddata->to_dev->kobj, &pwle_attr_group);
|
|
if (ddata->vib_ops->set_cp_trigger_index)
|
|
sysfs_remove_group(&ddata->to_dev->kobj, &cp_trigger_attr_group);
|
|
if (ddata->vib_ops->set_frequency)
|
|
sysfs_remove_group(&ddata->to_dev->kobj, &multi_freq_attr_group);
|
|
if (ddata->vib_ops->set_intensity)
|
|
sysfs_remove_file(&ddata->to_dev->kobj, &dev_attr_intensity.attr);
|
|
|
|
sysfs_remove_group(&ddata->to_dev->kobj, &sec_vibrator_attr_group);
|
|
|
|
device_destroy(ddata->to_class, MKDEV(0, 0));
|
|
class_destroy(ddata->to_class);
|
|
mutex_destroy(&ddata->vib_mutex);
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(sec_vibrator_unregister);
|
|
|
|
static int sec_vibrator_parse_dt(struct platform_device *pdev)
|
|
{
|
|
struct device_node *np = pdev->dev.of_node;
|
|
int ret = 0;
|
|
int temp;
|
|
|
|
pr_info("%s +++\n", __func__);
|
|
|
|
if (unlikely(!np)) {
|
|
pr_err("err: could not parse dt node\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
ret = of_property_read_u32(np, "haptic,normal_ratio", &temp);
|
|
if (ret) {
|
|
pr_err("%s: WARNING! normal_ratio not found\n", __func__);
|
|
sec_vibrator_pdata.normal_ratio = 100; // 100%
|
|
} else
|
|
sec_vibrator_pdata.normal_ratio = (int)temp;
|
|
|
|
ret = of_property_read_u32(np, "haptic,high_temp_ref", &temp);
|
|
if (ret) {
|
|
pr_info("%s: high temperature concept isn't used\n", __func__);
|
|
sec_vibrator_pdata.high_temp_ref = SEC_VIBRATOR_DEFAULT_HIGH_TEMP_REF;
|
|
} else {
|
|
sec_vibrator_pdata.high_temp_ref = (int)temp;
|
|
|
|
ret = of_property_read_u32(np, "haptic,high_temp_ratio", &temp);
|
|
if (ret) {
|
|
pr_info("%s: high_temp_ratio isn't used\n", __func__);
|
|
sec_vibrator_pdata.high_temp_ratio = SEC_VIBRATOR_DEFAULT_HIGH_TEMP_RATIO;
|
|
} else
|
|
sec_vibrator_pdata.high_temp_ratio = (int)temp;
|
|
}
|
|
|
|
pr_info("%s : done! ---\n", __func__);
|
|
return 0;
|
|
}
|
|
|
|
static int sec_vibrator_probe(struct platform_device *pdev)
|
|
{
|
|
pr_info("%s +++\n", __func__);
|
|
|
|
if (unlikely(sec_vibrator_parse_dt(pdev)))
|
|
pr_err("%s: WARNING!>..parse dt failed\n", __func__);
|
|
|
|
sec_vibrator_pdata.probe_done = true;
|
|
pr_info("%s : done! ---\n", __func__);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static const struct of_device_id sec_vibrator_id[] = {
|
|
{ .compatible = "sec_vibrator" },
|
|
{ }
|
|
};
|
|
|
|
static struct platform_driver sec_vibrator_driver = {
|
|
.probe = sec_vibrator_probe,
|
|
.driver = {
|
|
.name = "sec_vibrator",
|
|
.owner = THIS_MODULE,
|
|
.of_match_table = sec_vibrator_id,
|
|
},
|
|
};
|
|
|
|
module_platform_driver(sec_vibrator_driver);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_DESCRIPTION("sec vibrator driver");
|