jenna
/
kernel_samsung_sm7125
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
762308 Commits
5 Branches
0 Tags
1.2 GiB
 
 
 
Tag: Branch: Tree: fourteen
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'fourteen'
${ noResults }
kernel_samsung_sm7125/drivers/motor/ss_vibrator.c

1237 lines
32 KiB
Raw Permalink Blame History

/* Copyright (c) 2016, 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.
*/
#include <linux/kernel.h>
#include <linux/platform_device.h>
#include <linux/err.h>
#include <linux/hrtimer.h>
#include <linux/module.h>
#include <linux/gpio.h>
#include <linux/regulator/consumer.h>
#include <linux/workqueue.h>
#include <linux/of_gpio.h>
#include <linux/pinctrl/consumer.h>
#include <linux/pm_qos.h>
#include <linux/wakelock.h>
#include <linux/pwm.h>
#include "ss_vibrator.h"
#if defined(CONFIG_SLPI_MOTOR)
#include <linux/adsp/slpi_motor.h>
#endif
/* default timeout */
#define VIB_DEFAULT_TIMEOUT 10000
#define PACKET_MAX_SIZE 1000
#define MAX_LEN_VIB_TYPE 32
#define PMIC_HAPTIC_LDO 1
struct pm_qos_request pm_qos_req;
static struct wake_lock vib_wake_lock;
struct vib_tuning {
int m;
int n;
};
struct vib_packet {
int time;
int intensity;
int freq;
int overdrive;
};
struct ss_vib {
struct class *to_class;
struct device *to_dev;
struct device *dev;
struct hrtimer vib_timer;
struct work_struct work;
struct workqueue_struct *queue;
struct mutex lock;
struct mutex sysfs_lock;
struct pinctrl *pinctrl;
struct pinctrl_state *pin_active;
struct pinctrl_state *pin_suspend;
struct pwm_device *pwm_dev;
int state;
int timeout;
int intensity;
int force_touch_intensity;
int freq;
int timevalue;
int f_packet_en;
int packet_size;
int packet_cnt;
int f_overdrive_en;
int duty;
int period;
unsigned int vib_pwm_gpio; /* gpio number for vibrator pwm */
unsigned int vib_en_gpio; /* gpio number of vibrator enable */
unsigned int vib_power_gpio; /* gpio number of vibrator boost */
unsigned int flag_en_gpio;
enum driver_chip chip_model;
char vib_type[MAX_LEN_VIB_TYPE];
unsigned int gp_clk;
unsigned int m_default;
unsigned int n_default;
unsigned int motor_strength;
unsigned int strength_od;
unsigned int strength_default;
struct vib_tuning tuning[MAX_FREQUENCY];
struct vib_packet haptic_eng[PACKET_MAX_SIZE];
void (*power_onoff)(int onoff);
};
#if defined(CONFIG_BOOST_POWER_SHARE)
#define BOOST_REQUESTER_MOTOR 0
#define BOOST_REQUESTER_HRM 1
char boost_power_on(struct ss_vib *vib, char requester, char onoff)
{
static char motor_on, hrm_on;
if (requester == BOOST_REQUESTER_MOTOR) {
if (onoff)
motor_on = 1;
else
motor_on = 0;
}
if (requester == BOOST_REQUESTER_HRM) {
if (onoff)
hrm_on = 1;
else
hrm_on = 0;
}
if (vib != NULL) {
if (vib->vib_power_gpio > 0) {
if (motor_on || hrm_on)
gpio_direction_output(vib->vib_power_gpio, 1);
else
gpio_direction_output(vib->vib_power_gpio, 0);
} else {
pr_info("%s, didn't get gpio number\n", __func__);
return -EIO;
}
} else {
if (motor_on || hrm_on)
gpio_direction_output(1020, 1);
else
gpio_direction_output(1020, 0);
}
pr_info("%s, request[%s][%s] motor[%d], hrm[%d]\n", __func__, requester ? "HRM":"MOTOR",
onoff ? "ON":"OFF", motor_on, hrm_on);
return (motor_on || hrm_on);
}
EXPORT_SYMBOL(boost_power_on);
#endif
void vibe_set_intensity(int intensity)
{
if (intensity == 0)
vibe_pwm_onoff(0);
else {
if ((intensity < 0) || (intensity > MAX_INTENSITY)) {
intensity = MAX_INTENSITY;
pr_err("[VIB] used wrong intensity, force set [%d]\n", MAX_INTENSITY);
}
intensity = (intensity / 100); // 100 = 10000 / 100
vibe_set_pwm_freq(intensity);
vibe_pwm_onoff(1);
}
}
void vibe_set_freq(struct ss_vib *vib, int set_freq)
{
unsigned int ip_clock = 93750;
unsigned int freq = set_freq / 10;
unsigned int base_n = 0, n_m2 = 0, n_m3 = 0;
unsigned int m2_freq = 0, m3_freq = 0;
switch (set_freq) {
case freq_alert:
g_nlra_gp_clk_m = vib->tuning[freq_alert].m;
g_nlra_gp_clk_n = vib->tuning[freq_alert].n;
vib->freq = 158;
break;
case freq_low:
g_nlra_gp_clk_m = vib->tuning[freq_low].m;
g_nlra_gp_clk_n = vib->tuning[freq_low].n;
vib->freq = 120;
break;
case freq_mid:
g_nlra_gp_clk_m = vib->tuning[freq_mid].m;
g_nlra_gp_clk_n = vib->tuning[freq_mid].n;
vib->freq = 150;
break;
case freq_high:
g_nlra_gp_clk_m = vib->tuning[freq_high].m;
g_nlra_gp_clk_n = vib->tuning[freq_high].n;
vib->freq = 200;
break;
case freq_0:
g_nlra_gp_clk_m = vib->tuning[freq_0].m;
g_nlra_gp_clk_n = vib->tuning[freq_0].n;
vib->freq = 180;
break;
default:
vib->freq = freq; //19200000 / 16 / 128 = 9375
base_n = ip_clock / freq;
n_m2 = base_n * 2;
n_m2 = (n_m2 + 5) / 10; // round
n_m3 = base_n * 3;
n_m3 = (n_m3 + 5) / 10; // round
m2_freq = (ip_clock / n_m2) * 2;
m3_freq = (ip_clock / n_m3) * 3;
if (abs(set_freq - m2_freq) <= abs(set_freq - m3_freq)) {
g_nlra_gp_clk_m = 2;
g_nlra_gp_clk_n = n_m2;
} else {
g_nlra_gp_clk_m = 3;
g_nlra_gp_clk_n = n_m3;
}
break;
}
if (vib->f_overdrive_en)
motor_strength = vib->strength_od;
else
motor_strength = vib->strength_default;
g_nlra_gp_clk_d = g_nlra_gp_clk_n / 2;
g_nlra_gp_clk_pwm_mul = motor_strength;
motor_min_strength = g_nlra_gp_clk_n * MOTOR_MIN_STRENGTH / 100;
}
int32_t vibe_set_pwm_freq(int intensity)
{
int32_t calc_d;
int32_t calc_n, half_n;
/* Put the MND counter in reset mode for programming */
HWIO_OUTM(GPx_CFG_RCGR, HWIO_GP_SRC_SEL_VAL_BMSK,
0 << HWIO_GP_SRC_SEL_VAL_SHFT); //SRC_SEL = 000(cxo)
HWIO_OUTM(GPx_CFG_RCGR, HWIO_GP_SRC_DIV_VAL_BMSK,
31 << HWIO_GP_SRC_DIV_VAL_SHFT); //SRC_DIV = 11111 (Div 16)
HWIO_OUTM(GPx_CFG_RCGR, HWIO_GP_MODE_VAL_BMSK,
2 << HWIO_GP_MODE_VAL_SHFT); //Mode Select 10
//M value
HWIO_OUTM(GPx_M_REG, HWIO_GP_MD_REG_M_VAL_BMSK,
g_nlra_gp_clk_m << HWIO_GP_MD_REG_M_VAL_SHFT);
calc_n = (~(g_nlra_gp_clk_n - g_nlra_gp_clk_m) & 0xFF);
if (motor_strength > MAX_STRENGTH) {
motor_strength = MAX_STRENGTH;
pr_err("[VIB] used wrong motor_strength, force set [%d]\n", MAX_STRENGTH);
}
half_n = g_nlra_gp_clk_n >> 1; // div 2, 50% duty D value is N / 2
calc_d = (half_n * motor_strength) / 100;
calc_d = (calc_d * intensity) / 100;
calc_d = half_n - calc_d;
calc_d = (~(calc_d << 1) & 0xFF);
if (calc_d == 0xFF)
calc_d = 0xFE;
// D value
HWIO_OUTM(GPx_D_REG, HWIO_GP_MD_REG_D_VAL_BMSK, calc_d);
//N value
HWIO_OUTM(GPx_N_REG, HWIO_GP_N_REG_N_VAL_BMSK, calc_n);
return VIBRATION_SUCCESS;
}
int32_t vibe_pwm_onoff(u8 onoff)
{
if (onoff) {
HWIO_OUTM(GPx_CMD_RCGR, HWIO_UPDATE_VAL_BMSK,
1 << HWIO_UPDATE_VAL_SHFT);//UPDATE ACTIVE
HWIO_OUTM(GPx_CMD_RCGR, HWIO_ROOT_EN_VAL_BMSK,
1 << HWIO_ROOT_EN_VAL_SHFT);//ROOT_EN
HWIO_OUTM(CAMSS_GPx_CBCR, HWIO_CLK_ENABLE_VAL_BMSK,
1 << HWIO_CLK_ENABLE_VAL_SHFT); //CLK_ENABLE
} else {
HWIO_OUTM(GPx_CMD_RCGR, HWIO_UPDATE_VAL_BMSK,
0 << HWIO_UPDATE_VAL_SHFT);
HWIO_OUTM(GPx_CMD_RCGR, HWIO_ROOT_EN_VAL_BMSK,
0 << HWIO_ROOT_EN_VAL_SHFT);
HWIO_OUTM(CAMSS_GPx_CBCR, HWIO_CLK_ENABLE_VAL_BMSK,
0 << HWIO_CLK_ENABLE_VAL_SHFT);
}
return VIBRATION_SUCCESS;
}
static void max778xx_haptic_en(struct ss_vib *vib, bool onoff)
{
switch (vib->chip_model) {
#if defined(CONFIG_MOTOR_DRV_MAX77854)
case CHIP_MAX77854:
max77854_vibtonz_en(onoff);
break;
#endif
#if defined(CONFIG_MOTOR_DRV_SM5720)
case CHIP_SM5720:
sm5720_vibtonz_en(onoff);
break;
#endif
#if defined(CONFIG_MOTOR_DRV_MAX77705)
case CHIP_MAX77705:
max77705_vibtonz_en(onoff);
break;
#endif
default:
break;
}
}
static void set_vibrator(struct ss_vib *vib)
{
// int ret;
pr_info("[VIB]: %s, value[%d]\n", __func__, vib->state);
if (vib->state) {
wake_lock(&vib_wake_lock);
pm_qos_update_request(&pm_qos_req, PM_QOS_NONIDLE_VALUE);
#if defined(CONFIG_SLPI_MOTOR)
setSensorCallback(true, vib->timevalue);
#endif
#if defined(CONFIG_BOOST_POWER_SHARE)
boost_power_on(vib, BOOST_REQUESTER_MOTOR, 1);
#else
if (vib->power_onoff)
vib->power_onoff(1);
#endif
if (vib->flag_en_gpio)
gpio_set_value(vib->vib_en_gpio, VIBRATION_ON);
hrtimer_start(&vib->vib_timer, ktime_set(vib->timevalue / 1000,
(vib->timevalue % 1000) * 1000000), HRTIMER_MODE_REL);
} else {
if (vib->flag_en_gpio)
gpio_set_value(vib->vib_en_gpio, VIBRATION_OFF);
#if defined(CONFIG_BOOST_POWER_SHARE)
boost_power_on(vib, BOOST_REQUESTER_MOTOR, 0);
#else
if (vib->power_onoff)
vib->power_onoff(0);
#endif
#if defined(CONFIG_SLPI_MOTOR)
setSensorCallback(false, vib->timevalue);
#endif
//PM_QOS_DEFAULT_VALUE
wake_unlock(&vib_wake_lock);
pm_qos_update_request(&pm_qos_req, PM_QOS_DEFAULT_VALUE);
}
pr_info("[VIB]: %s, vibrator control finish value[%d]\n", __func__, vib->state);
}
static void vibrator_enable(struct ss_vib *vib, int value)
{
mutex_lock(&vib->lock);
hrtimer_cancel(&vib->vib_timer);
if (value == 0) {
pr_info("[VIB]: OFF\n");
vib->state = 0;
vib->timevalue = 0;
/*for packet disable*/
vib->f_packet_en = 0;
vib->packet_cnt = 0;
vib->packet_size = 0;
vib->f_overdrive_en = false;
} else {
vib->state = 1;
vib->timevalue = value;
if (f_multi_freq) {
if (vib->f_packet_en) {
vib->f_overdrive_en = vib->haptic_eng[0].overdrive;
vibe_set_freq(vib, vib->haptic_eng[0].freq);
vibe_set_intensity(vib->haptic_eng[0].intensity);
vib->timevalue = vib->haptic_eng[0].time;
vib->intensity = vib->haptic_eng[0].intensity;
pr_info("[VIB] packet enabled");
}
pr_info("[VIB]: ON, Duration : %d msec, intensity : %d, freq : %d strength : %d od : %d\n",
vib->timevalue, vib->intensity, vib->freq, motor_strength, vib->f_overdrive_en);
} else {
pr_info("[VIB]: ON, Duration : %d msec, intensity : %d, strength : %d od : %d\n",
vib->timevalue, vib->intensity, motor_strength, vib->f_overdrive_en);
}
}
mutex_unlock(&vib->lock);
queue_work(vib->queue, &vib->work);
}
static void ss_vibrator_update(struct work_struct *work)
{
struct ss_vib *vib = container_of(work, struct ss_vib, work);
set_vibrator(vib);
}
static enum hrtimer_restart vibrator_timer_func(struct hrtimer *timer)
{
struct ss_vib *vib = container_of(timer, struct ss_vib, vib_timer);
int power_on;
if (vib->f_packet_en) {
if (++vib->packet_cnt >= vib->packet_size) {
vib->state = 0;
vib->f_packet_en = 0;
vib->packet_cnt = 0;
vib->packet_size = 0;
vib->f_overdrive_en = false;
queue_work(vib->queue, &vib->work);
} else {
power_on = vib->haptic_eng[vib->packet_cnt].intensity ? 1 : 0;
#if defined(CONFIG_BOOST_POWER_SHARE)
boost_power_on(vib, BOOST_REQUESTER_MOTOR, power_on);
#else
if (vib->power_onoff)
vib->power_onoff(power_on);
#endif
vib->f_overdrive_en = vib->haptic_eng[vib->packet_cnt].overdrive;
vibe_set_freq(vib, vib->haptic_eng[vib->packet_cnt].freq);
vibe_set_intensity(vib->haptic_eng[vib->packet_cnt].intensity);
vib->timevalue = vib->haptic_eng[vib->packet_cnt].time;
vib->intensity = vib->haptic_eng[vib->packet_cnt].intensity;
pr_info("[VIB] %s time[%d] intensity[%d] freq[%d](m=%d,n=%d) od[%d]\n", __func__,
vib->timevalue, vib->intensity, vib->freq,
g_nlra_gp_clk_m, g_nlra_gp_clk_n, vib->f_overdrive_en);
hrtimer_forward_now(timer, ktime_set(vib->timevalue / 1000, (vib->timevalue % 1000) * 1000000));
return HRTIMER_RESTART;
}
} else {
vib->state = 0;
queue_work(vib->queue, &vib->work);
}
return HRTIMER_NORESTART;
}
#if defined(CONFIG_PM)
static int ss_vibrator_suspend(struct device *dev)
{
struct ss_vib *vib = dev_get_drvdata(dev);
pr_info("[VIB]: %s\n", __func__);
hrtimer_cancel(&vib->vib_timer);
cancel_work_sync(&vib->work);
/* turn-off vibrator */
set_vibrator(vib);
max778xx_haptic_en(vib, false);
return 0;
}
static int ss_vibrator_resume(struct device *dev)
{
struct ss_vib *vib = dev_get_drvdata(dev);
pr_info("[VIB]: %s\n", __func__);
max778xx_haptic_en(vib, true);
return 0;
}
#endif
static SIMPLE_DEV_PM_OPS(vibrator_pm_ops, ss_vibrator_suspend, ss_vibrator_resume);
static int vibrator_parse_dt(struct ss_vib *vib)
{
struct device_node *np = vib->dev->of_node;
const char *type;
int rc;
vib->vib_pwm_gpio = of_get_named_gpio(np, "samsung,vib_pwm", 0);
if (!gpio_is_valid(vib->vib_pwm_gpio))
pr_err("%s:%d, reset gpio not specified\n", __func__, __LINE__);
vib->vib_en_gpio = of_get_named_gpio(np, "samsung,vib_en", 0);
if (!gpio_is_valid(vib->vib_en_gpio)) {
vib->flag_en_gpio = 0;
pr_info("%s:%d, en gpio not specified\n", __func__, __LINE__);
} else {
vib->flag_en_gpio = 1;
gpio_direction_output(vib->vib_en_gpio, 0);
}
vib->vib_power_gpio = of_get_named_gpio(np, "samsung,vib_power", 0);
if (!gpio_is_valid(vib->vib_power_gpio))
pr_err("%s:%d, power gpio not specified\n", __func__, __LINE__);
rc = of_property_read_u32(np, "samsung,chip_model", &vib->chip_model);
if (rc == 2) {
pr_info("chip_model is SM5720\n");
vib->chip_model = CHIP_SM5720;
} else if (rc == 4) {
pr_info("chip_model is MAX77705\n");
vib->chip_model = CHIP_MAX77705;
} else
pr_info("There isn't any chip model\n");
rc = of_property_read_string(np, "samsung,vib_type", &type);
if (rc) {
pr_info("%s: motor type not specified\n", __func__);
snprintf(vib->vib_type, sizeof(vib->vib_type), "%s", "NONE");
rc = 0;
} else {
snprintf(vib->vib_type, sizeof(vib->vib_type), "%s", type);
}
rc = of_property_read_u32(np, "samsung,gp_clk", &vib->gp_clk);
if (rc) {
pr_info("gp_clk not specified so using default address\n");
vib->gp_clk = MSM_GCC_GPx_BASE;
rc = 0;
}
rc = of_property_read_u32(np, "samsung,support_multi_freq", &f_multi_freq);
if (rc) {
pr_info("support_multi_freq not specified so don't support multi freq\n");
f_multi_freq = 0;
rc = 0;
}
rc = of_property_read_u32(np, "samsung,strength_od", &vib->strength_od);
if (rc) {
pr_info("strength not specified so use default strength\n");
vib->strength_od = 94;
rc = 0;
}
rc = of_property_read_u32(np, "samsung,strength_default", &vib->strength_default);
if (rc) {
pr_info("support_multi_freq not specified so don't support multi freq\n");
vib->strength_default = 60;
rc = 0;
}
if (f_multi_freq) {
int ret;
int array_val[2];
ret = of_property_read_u32_array(np, "samsung,freq_0", array_val, 2);
if (ret) {
pr_info("%s: Unable to read freq_0\n", __func__);
array_val[0] = GP_CLK_M_DEFAULT;
array_val[1] = GP_CLK_N_DEFAULT;
}
vib->tuning[freq_0].m = array_val[0];
vib->tuning[freq_0].n = array_val[1];
ret = of_property_read_u32_array(np, "samsung,freq_low", array_val, 2);
if (ret) {
pr_info("%s: Unable to read freq_low\n", __func__);
array_val[0] = GP_CLK_M_DEFAULT;
array_val[1] = GP_CLK_N_DEFAULT;
}
vib->tuning[freq_low].m = array_val[0];
vib->tuning[freq_low].n = array_val[1];
ret = of_property_read_u32_array(np, "samsung,freq_mid", array_val, 2);
if (ret) {
pr_info("%s: Unable to read freq_mid\n", __func__);
array_val[0] = GP_CLK_M_DEFAULT;
array_val[1] = GP_CLK_N_DEFAULT;
}
vib->tuning[freq_mid].m = array_val[0];
vib->tuning[freq_mid].n = array_val[1];
ret = of_property_read_u32_array(np, "samsung,freq_high", array_val, 2);
if (ret) {
pr_info("%s: Unable to read freq_high\n", __func__);
array_val[0] = GP_CLK_M_DEFAULT;
array_val[1] = GP_CLK_N_DEFAULT;
}
vib->tuning[freq_high].m = array_val[0];
vib->tuning[freq_high].n = array_val[1];
ret = of_property_read_u32_array(np, "samsung,freq_alert", array_val, 2);
if (ret) {
pr_info("%s: Unable to read freq_alert\n", __func__);
array_val[0] = GP_CLK_M_DEFAULT;
array_val[1] = GP_CLK_N_DEFAULT;
}
vib->tuning[freq_alert].m = array_val[0];
vib->tuning[freq_alert].n = array_val[1];
} else {
rc = of_property_read_u32(np, "samsung,m_default", &vib->m_default);
if (rc) {
pr_info("m_default not specified so using default address\n");
vib->m_default = GP_CLK_M_DEFAULT;
rc = 0;
}
rc = of_property_read_u32(np, "samsung,n_default", &vib->n_default);
if (rc) {
pr_info("n_default not specified so using default address\n");
vib->n_default = GP_CLK_N_DEFAULT;
rc = 0;
}
rc = of_property_read_u32(np, "samsung,motor_strength", &motor_strength);
if (rc) {
pr_info("motor_strength not specified so using default address\n");
motor_strength = MOTOR_STRENGTH;
rc = 0;
}
}
return rc;
}
static struct device *vib_dev;
static ssize_t show_vib_tuning(struct device *dev,
struct device_attribute *attr, char *buf)
{
sprintf(buf, "gp_m %d, gp_n %d, gp_d %d, pwm_mul %d, strength %d, min_str %d\n",
g_nlra_gp_clk_m, g_nlra_gp_clk_n, g_nlra_gp_clk_d,
g_nlra_gp_clk_pwm_mul, motor_strength, motor_min_strength);
return strlen(buf);
}
static ssize_t store_vib_tuning(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
int retval;
int temp_m, temp_n, temp_str;
retval = sscanf(buf, "%1d %3d %2d", &temp_m, &temp_n, &temp_str);
if (retval != 3) {
pr_info("[VIB]: %s, fail to get vib_tuning value\n", __func__);
return count;
}
g_nlra_gp_clk_m = temp_m;
g_nlra_gp_clk_n = temp_n;
g_nlra_gp_clk_d = temp_n / 2;
g_nlra_gp_clk_pwm_mul = temp_n;
motor_strength = temp_str;
motor_min_strength = g_nlra_gp_clk_n*MOTOR_MIN_STRENGTH/100;
pr_info("[VIB]: %s gp_m %d, gp_n %d, gp_d %d, pwm_mul %d, strength %d, min_str %d\n", __func__,
g_nlra_gp_clk_m, g_nlra_gp_clk_n, g_nlra_gp_clk_d,
g_nlra_gp_clk_pwm_mul, motor_strength, motor_min_strength);
return count;
}
static DEVICE_ATTR(vib_tuning, 0660, show_vib_tuning, store_vib_tuning);
static ssize_t intensity_store(struct device *dev,
struct device_attribute *devattr, const char *buf, size_t count)
{
struct ss_vib *vib = dev_get_drvdata(dev);
int ret = 0, set_intensity = 0;
ret = kstrtoint(buf, 0, &set_intensity);
if (ret) {
pr_err("[VIB]: %s failed to get intensity", __func__);
return ret;
}
if ((set_intensity < 0) || (set_intensity > MAX_INTENSITY)) {
pr_err("[VIB]: %sout of rage\n", __func__);
return -EINVAL;
}
vibe_set_intensity(set_intensity);
vib->intensity = set_intensity;
return count;
}
static ssize_t intensity_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct ss_vib *vib = dev_get_drvdata(dev);
return sprintf(buf, "intensity: %u\n", vib->intensity);
}
static DEVICE_ATTR(intensity, 0660, intensity_show, intensity_store);
static ssize_t force_touch_intensity_store(struct device *dev,
struct device_attribute *devattr, const char *buf, size_t count)
{
struct ss_vib *vib = dev_get_drvdata(dev);
int ret = 0, set_intensity = 0;
ret = kstrtoint(buf, 0, &set_intensity);
if (ret) {
pr_err("[VIB]: %s failed to get force touch intensity", __func__);
return ret;
}
if ((set_intensity < 0) || (set_intensity > MAX_INTENSITY)) {
pr_err("[VIB]: %sout of rage\n", __func__);
return -EINVAL;
}
vibe_set_intensity(set_intensity);
vib->force_touch_intensity = set_intensity;
return count;
}
static ssize_t force_touch_intensity_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct ss_vib *vib = dev_get_drvdata(dev);
return sprintf(buf, "force touch intensity: %u\n", vib->force_touch_intensity);
}
static DEVICE_ATTR(force_touch_intensity, 0660, force_touch_intensity_show, force_touch_intensity_store);
static ssize_t multi_freq_store(struct device *dev,
struct device_attribute *devattr, const char *buf, size_t count)
{
struct ss_vib *vib = dev_get_drvdata(dev);
int ret = 0, set_freq = 0;
ret = kstrtoint(buf, 0, &set_freq);
if (ret) {
pr_err("[VIB]: %s failed to get multi_freq value", __func__);
return ret;
}
if ((set_freq < 0) || (set_freq >= MAX_FREQUENCY)) {
pr_err("[VIB]: %s out of freq range\n", __func__);
return -EINVAL;
}
vibe_set_freq(vib, set_freq);
pr_info("[VIB]: %s gp_m %d, gp_n %d, gp_d %d, pwm_mul %d, strength %d, min_str %d\n", __func__,
g_nlra_gp_clk_m, g_nlra_gp_clk_n, g_nlra_gp_clk_d,
g_nlra_gp_clk_pwm_mul, motor_strength, motor_min_strength);
return count;
}
static ssize_t multi_freq_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct ss_vib *vib = dev_get_drvdata(dev);
return sprintf(buf, "%s %d\n", f_multi_freq ? "MULTI" : "FIXED", vib->freq);
}
static DEVICE_ATTR(multi_freq, 0660, multi_freq_show, multi_freq_store);
static ssize_t haptic_engine_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct ss_vib *vib = dev_get_drvdata(dev);
int i = 0, _data = 0, skip = 0;
if (sscanf(buf, "%4u %n", &_data, &skip) != 1)
goto invalid_data;
if (_data > PACKET_MAX_SIZE * 4)
goto invalid_data;
vib->f_packet_en = false;
vib->f_overdrive_en = false;
vib->packet_size = _data / 4;
vib->packet_cnt = 0;
for (i = 0; i < vib->packet_size; i++) {
unsigned data[4] = { 0 };
buf += skip;
if (sscanf(buf, "%5u %5u %5u %5u %n", &data[0], &data[1],
&data[2], &data[3], &skip) != 4) {
goto invalid_data;
}
vib->haptic_eng[i].time = data[0];
vib->haptic_eng[i].intensity = data[1];
vib->haptic_eng[i].freq = data[2];
vib->haptic_eng[i].overdrive = data[3];
}
vib->f_packet_en = true;
vib->f_overdrive_en = true;
return size;
invalid_data:
pr_err("%s, packet data error, Please check again\n", __func__);
return -EINVAL;
}
static ssize_t haptic_engine_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
struct ss_vib *vib = dev_get_drvdata(dev);
int i = 0, tmp = 0;
size_t size = 0;
mutex_lock(&vib->sysfs_lock);
size += snprintf(&buf[size], VIB_BUFSIZE, "\n");
for (i = 0; i < vib->packet_size && vib->f_packet_en &&
((4 * VIB_BUFSIZE + size) < PAGE_SIZE); i++) {
for (tmp = 0; tmp < 4; tmp++) {
switch (tmp) {
case 0:
size += snprintf(&buf[size], VIB_BUFSIZE, "%u ", vib->haptic_eng[i].time);
break;
case 1:
size += snprintf(&buf[size], VIB_BUFSIZE, "%u ", vib->haptic_eng[i].intensity);
break;
case 2:
size += snprintf(&buf[size], VIB_BUFSIZE, "%u ", vib->haptic_eng[i].freq);
break;
case 3:
size += snprintf(&buf[size], VIB_BUFSIZE, "%u ", vib->haptic_eng[i].overdrive);
break;
}
}
}
size += snprintf(&buf[size], PACKET_MAX_SIZE * 4, "\n");
mutex_unlock(&vib->sysfs_lock);
return size;
}
static DEVICE_ATTR(haptic_engine, 0660, haptic_engine_show, haptic_engine_store);
static ssize_t enable_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
struct ss_vib *vib = dev_get_drvdata(dev);
struct hrtimer *timer = &vib->vib_timer;
int remaining = 0;
if (hrtimer_active(timer)) {
ktime_t remain = hrtimer_get_remaining(timer);
struct timeval t = ktime_to_timeval(remain);
remaining = t.tv_sec * 1000 + t.tv_usec / 1000;
}
return sprintf(buf, "%d\n", remaining);
}
static ssize_t enable_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t size)
{
struct ss_vib *vib = dev_get_drvdata(dev);
int value;
int ret;
ret = kstrtoint(buf, 0, &value);
if (ret != 0)
return -EINVAL;
vibrator_enable(vib, value);
return size;
}
static DEVICE_ATTR(enable, 0660, enable_show, enable_store);
static ssize_t motor_type_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
struct ss_vib *vib = dev_get_drvdata(dev);
pr_info("%s: %s\n", __func__, vib->vib_type);
return snprintf(buf, MAX_LEN_VIB_TYPE, "%s\n", vib->vib_type);
}
static DEVICE_ATTR(motor_type, 0660, motor_type_show, NULL);
static ssize_t pwm_active_store(struct device *dev,
struct device_attribute *devattr, const char *buf, size_t count)
{
struct ss_vib *vib = dev_get_drvdata(dev);
struct pwm_state pstate;
int ret = 0;
int period = 0, duty = 0;
ret = sscanf(buf, "%d %d", &duty, &period);
if (ret) {
pr_err("[VIB]: %s failed to get pwm value", __func__);
return ret;
}
vib->period = period;
vib->duty = duty;
pwm_get_state(vib->pwm_dev, &pstate);
pstate.enabled = true;
pstate.period = period;
pstate.duty_cycle = duty;
pstate.output_type = PWM_OUTPUT_FIXED;
/* Use default pattern in PWM device */
pstate.output_pattern = NULL;
ret = pwm_apply_state(vib->pwm_dev, &pstate);
if (ret< 0)
dev_err(vib->dev, "Apply PWM state for sliding motor failed, rc=%d\n", ret);
return count;
}
static ssize_t pwm_active_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct ss_vib *vib = dev_get_drvdata(dev);
return sprintf(buf, "%d %d\n", vib->duty, vib->period);
}
static DEVICE_ATTR(pwm_active, 0660, pwm_active_show, pwm_active_store);
#if !defined(CONFIG_BOOST_POWER_SHARE)
static void regulator_power_onoff(int onoff)
{
#if !defined(PMIC_HAPTIC_LDO)
static struct regulator *reg_ldo;
int ret;
#endif
#if defined(PMIC_HAPTIC_LDO)
ss_vib_ldo_enable(onoff);
pr_info("[VIB] enable pmic haptic ldo\n");
#else
if (!reg_ldo) {
reg_ldo = regulator_get(NULL, "pm6150_l16");
if (IS_ERR(reg_ldo)) {
pr_info("could not get 8998_ldo, rc = %ld\n", PTR_ERR(reg_ldo));
return;
}
if (f_multi_freq)
ret = regulator_set_voltage(reg_ldo, 3350000, 3350000);
else
ret = regulator_set_voltage(reg_ldo, 2800000, 2800000);
}
if (onoff) {
if (regulator_is_enabled(reg_ldo)) {
pr_info("[VIB]: power_on already\n");
} else {
ret = regulator_set_load(reg_ldo, 10000);
if (ret < 0) {
pr_info("regulator_set_load pmcobalt_l25 failed, rc=%d\n", ret);
return;
}
ret = regulator_enable(reg_ldo);
if (ret) {
pr_info("enable ldo failed, rc=%d\n", ret);
return;
}
pr_info("[VIB]: power_on now\n");
}
} else {
if (regulator_is_enabled(reg_ldo)) {
ret = regulator_set_load(reg_ldo, 0);
if (ret < 0)
pr_info("regulator_set_load pmcobalt_l25 failed, rc=%d\n", ret);
ret = regulator_disable(reg_ldo);
if (ret) {
pr_info("disable ldo failed, rc=%d\n", ret);
return;
}
pr_info("[VIB]: power_off now\n");
} else {
pr_info("[VIB]: power_off already\n");
}
}
#endif
}
#else
static void regulator_power_onoff(int onoff)
{
}
#endif
extern int haptic_homekey_press(void)
{
/*for drv2624 panic prevention*/
if (g_vib == NULL) {
pr_info("[VIB] %s : NULL reference, return\n", __func__);
return -1;
}
mutex_lock(&g_vib->lock);
max778xx_haptic_en(g_vib, true);
g_vib->f_overdrive_en = true;
g_vib->timevalue = 7;
vibe_set_freq(g_vib, 2000);
vibe_set_intensity(g_vib->force_touch_intensity);
g_vib->state = 1;
pr_info("[VIB] %s : time: %dmsec, intensity: %d, freq: %d, strength : %d\n", __func__,
g_vib->timevalue, g_vib->force_touch_intensity, g_vib->freq, motor_strength);
g_vib->f_overdrive_en = false;
mutex_unlock(&g_vib->lock);
queue_work(g_vib->queue, &g_vib->work);
return 0;
}
extern int haptic_homekey_release(void)
{
/*for drv2624 panic prevention*/
if (g_vib == NULL) {
pr_info("[VIB] %s : NULL reference, return\n", __func__);
return -1;
}
mutex_lock(&g_vib->lock);
g_vib->f_overdrive_en = true;
g_vib->timevalue = 7;
vibe_set_freq(g_vib, 2000);
vibe_set_intensity(g_vib->force_touch_intensity);
g_vib->state = 1;
pr_info("[VIB] %s : time: %dmsec, intensity: %d, freq: %d, strength : %d\n", __func__,
g_vib->timevalue, g_vib->force_touch_intensity, g_vib->freq, motor_strength);
g_vib->f_overdrive_en = false;
mutex_unlock(&g_vib->lock);
queue_work(g_vib->queue, &g_vib->work);
return 0;
}
static int ss_vibrator_probe(struct platform_device *pdev)
{
struct ss_vib *vib;
int rc = 0;
pr_info("[VIB]: %s\n", __func__);
vib = devm_kzalloc(&pdev->dev, sizeof(*vib), GFP_KERNEL);
if (!vib)
return -ENOMEM;
if (!pdev->dev.of_node) {
pr_err("[VIB]: %s failed, DT is NULL", __func__);
return -ENODEV;
}
vib->dev = &pdev->dev;
rc = vibrator_parse_dt(vib);
if (rc)
return rc;
virt_mmss_gp1_base = ioremap(vib->gp_clk, 0x28);
if (!virt_mmss_gp1_base)
panic("[VIB]: Unable to ioremap MSM_MMSS_GP1 memory!");
#if defined(CONFIG_BOOST_POWER_SHARE)
boost_power_on(vib, BOOST_REQUESTER_MOTOR, 0);
#else
vib->power_onoff = regulator_power_onoff;
#endif
vib->intensity = MAX_INTENSITY;
vib->force_touch_intensity = MAX_INTENSITY;
if (f_multi_freq) {
g_nlra_gp_clk_m = vib->tuning[freq_alert].m;
g_nlra_gp_clk_n = vib->tuning[freq_alert].n;
vib->freq = freq_alert;
} else {
g_nlra_gp_clk_m = vib->m_default;
g_nlra_gp_clk_n = vib->n_default;
vib->freq = MAX_FREQUENCY;
}
g_nlra_gp_clk_d = (g_nlra_gp_clk_n / 2);
g_nlra_gp_clk_pwm_mul = g_nlra_gp_clk_n;
motor_min_strength = g_nlra_gp_clk_n * MOTOR_MIN_STRENGTH/100;
vib->timeout = VIB_DEFAULT_TIMEOUT;
vibe_set_intensity(vib->intensity);
INIT_WORK(&vib->work, ss_vibrator_update);
mutex_init(&vib->lock);
mutex_init(&vib->sysfs_lock);
vib->queue = create_singlethread_workqueue("ss_vibrator");
if (!vib->queue) {
pr_err("[VIB]: %s: can't create workqueue\n", __func__);
return -ENOMEM;
}
hrtimer_init(&vib->vib_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
vib->vib_timer.function = vibrator_timer_func;
gpio_set_value(vib->vib_pwm_gpio, VIBRATION_OFF);
dev_set_drvdata(&pdev->dev, vib);
g_vib = vib;
max778xx_haptic_en(vib, true);
vib->to_class = class_create(THIS_MODULE, "timed_output");
if (IS_ERR(vib->to_class)) {
pr_err("[VIB]: timed_output classs create fail (rc=%d)\n", rc);
goto err_read_vib;
}
vib->to_dev = device_create(vib->to_class, NULL, 0, vib, "vibrator");
if (IS_ERR(vib->to_dev))
return PTR_ERR(vib->to_dev);
rc = sysfs_create_file(&vib->to_dev->kobj, &dev_attr_enable.attr);
if (rc < 0)
pr_err("[VIB]: Failed to register sysfs enable: %d\n", rc);
if (strcmp(vib->vib_type, "COINDC")) {
rc = sysfs_create_file(&vib->to_dev->kobj, &dev_attr_intensity.attr);
if (rc < 0)
pr_err("[VIB]: Failed to register sysfs intensity: %d\n", rc);
}
rc = sysfs_create_file(&vib->to_dev->kobj, &dev_attr_motor_type.attr);
if (rc < 0)
pr_err("[VIB]: Failed to register sysfs motor type: %d\n", rc);
if (f_multi_freq) {
rc = sysfs_create_file(&vib->to_dev->kobj, &dev_attr_force_touch_intensity.attr);
if (rc < 0)
pr_err("[VIB]: Failed to register sysfs force_touch_intensity: %d\n", rc);
rc = sysfs_create_file(&vib->to_dev->kobj, &dev_attr_multi_freq.attr);
if (rc < 0)
pr_err("[VIB]: Failed to register sysfs multi_freq: %d\n", rc);
rc = sysfs_create_file(&vib->to_dev->kobj, &dev_attr_haptic_engine.attr);
if (rc < 0)
pr_err("[VIB]: Failed to register sysfs haptic_engine: %d\n", rc);
}
rc = sysfs_create_file(&vib->to_dev->kobj, &dev_attr_pwm_active.attr);
if (rc < 0)
pr_err("[VIB]: Failed to register sysfs intensity: %d\n", rc);
vib_dev = device_create(vib->to_class, NULL, 0, vib, "vib");
if (IS_ERR(vib_dev))
pr_info("[VIB]: Failed to create device for samsung vib\n");
rc = sysfs_create_file(&vib_dev->kobj, &dev_attr_vib_tuning.attr);
if (rc)
pr_info("Failed to create sysfs group for samsung specific led\n");
wake_lock_init(&vib_wake_lock, WAKE_LOCK_SUSPEND, "vib_present");
pm_qos_add_request(&pm_qos_req, PM_QOS_CPU_DMA_LATENCY, PM_QOS_DEFAULT_VALUE);
vib->pinctrl = devm_pinctrl_get(&pdev->dev);
if (IS_ERR(vib->pinctrl)) {
pr_err("[VIB]: Failed to get pinctrl(%d)\n", IS_ERR(vib->pinctrl));
} else {
vib->pin_active = pinctrl_lookup_state(vib->pinctrl, "tlmm_pwm_default");
if (IS_ERR(vib->pin_active)) {
pr_err("[VIB]: Failed to get pin_active(%d)\n", IS_ERR(vib->pin_active));
} else {
rc = pinctrl_select_state(vib->pinctrl, vib->pin_active);
if (rc)
pr_err("[VIB]: can not change pin_suspend\n");
}
}
return 0;
err_read_vib:
iounmap(virt_mmss_gp1_base);
destroy_workqueue(vib->queue);
mutex_destroy(&vib->lock);
mutex_destroy(&vib->sysfs_lock);
return rc;
}
static int ss_vibrator_remove(struct platform_device *pdev)
{
struct ss_vib *vib = dev_get_drvdata(&pdev->dev);
iounmap(virt_mmss_gp1_base);
pm_qos_remove_request(&pm_qos_req);
destroy_workqueue(vib->queue);
mutex_destroy(&vib->lock);
mutex_destroy(&vib->sysfs_lock);
wake_lock_destroy(&vib_wake_lock);
return 0;
}
static const struct of_device_id vib_motor_match[] = {
{ .compatible = "samsung_vib",
},
{}
};
static struct platform_driver ss_vibrator_platdrv = {
.driver = {
.name = "samsung_vib",
.owner = THIS_MODULE,
.of_match_table = vib_motor_match,
.pm = &vibrator_pm_ops,
},
.probe = ss_vibrator_probe,
.remove = ss_vibrator_remove,
};
static int __init ss_timed_vibrator_init(void)
{
return platform_driver_register(&ss_vibrator_platdrv);
}
void __exit ss_timed_vibrator_exit(void)
{
platform_driver_unregister(&ss_vibrator_platdrv);
}
module_init(ss_timed_vibrator_init);
module_exit(ss_timed_vibrator_exit);
MODULE_AUTHOR("Samsung Corporation");
MODULE_DESCRIPTION("timed output vibrator device");
MODULE_LICENSE("GPL v2");