/**
* pm8xxx_work_handler - worker to set vibration level
* @work: pointer to work_struct
*/
static void pm8xxx_work_handler(struct work_struct *work)
{
struct pm8xxx_vib *vib = container_of(work, struct pm8xxx_vib, work);
int rc;
u8 val;
rc = pm8xxx_vib_read_u8(vib, &val, VIB_DRV);
if (rc < 0)
return;
/*
* pmic vibrator supports voltage ranges from 1.2 to 3.1V, so
* scale the level to fit into these ranges.
*/
if (vib->speed) {
vib->active = true;
vib->level = ((VIB_MAX_LEVELS * vib->speed) / MAX_FF_SPEED) +
VIB_MIN_LEVEL_mV;
vib->level /= 100;
} else {
vib->active = false;
vib->level = VIB_MIN_LEVEL_mV / 100;
}
pm8xxx_vib_set(vib, vib->active);
}
static void pm8xxx_work_handler(struct work_struct *work)
{
struct pm8xxx_vib *vib = container_of(work, struct pm8xxx_vib, work);
int rc;
u8 val;
rc = pm8xxx_vib_read_u8(vib, &val, VIB_DRV);
if (rc < 0)
return;
if (vib->speed) {
vib->active = true;
vib->level = ((VIB_MAX_LEVELS * vib->speed) / MAX_FF_SPEED) +
VIB_MIN_LEVEL_mV;
vib->level /= 100;
} else {
vib->active = false;
vib->level = VIB_MIN_LEVEL_mV / 100;
}
pm8xxx_vib_set(vib, vib->active);
}
static int __devinit pm8xxx_vib_probe(struct platform_device *pdev)
{
const struct pm8xxx_vibrator_platform_data *pdata =
pdev->dev.platform_data;
struct pm8xxx_vib *vib;
u8 val;
int rc;
if (!pdata)
return -EINVAL;
if (pdata->level_mV < VIB_MIN_LEVEL_mV ||
pdata->level_mV > VIB_MAX_LEVEL_mV)
return -EINVAL;
vib = kzalloc(sizeof(*vib), GFP_KERNEL);
if (!vib)
return -ENOMEM;
vib->pdata = pdata;
vib->level = pdata->level_mV / 100;
vib->dev = &pdev->dev;
spin_lock_init(&vib->lock);
INIT_WORK(&vib->work, pm8xxx_vib_update);
hrtimer_init(&vib->vib_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
vib->vib_timer.function = pm8xxx_vib_timer_func;
vib->timed_dev.name = "vibrator";
vib->timed_dev.get_time = pm8xxx_vib_get_time;
vib->timed_dev.enable = pm8xxx_vib_enable;
__dump_vib_regs(vib, "boot_vib_default");
/*
* Configure the vibrator, it operates in manual mode
* for timed_output framework.
*/
rc = pm8xxx_vib_read_u8(vib, &val, VIB_DRV);
if (rc < 0)
goto err_read_vib;
val &= ~VIB_DRV_EN_MANUAL_MASK;
rc = pm8xxx_vib_write_u8(vib, val, VIB_DRV);
if (rc < 0)
goto err_read_vib;
vib->reg_vib_drv = val;
rc = timed_output_dev_register(&vib->timed_dev);
if (rc < 0)
goto err_read_vib;
rc = device_create_file(vib->timed_dev.dev, &dev_attr_voltage_level);
if (rc < 0) {
VIB_ERR_LOG("%s, create sysfs fail: voltage_level\n", __func__);
}
platform_set_drvdata(pdev, vib);
vib_dev = vib;
return 0;
err_read_vib:
kfree(vib);
return rc;
}
static int vibrator_probe(struct platform_device *pdev)
{
int nRet, i; /* initialized below */
#if !defined(CONFIG_MACH_LGE_L9II_OPEN_EU)
u8 val;
vib_dev = kzalloc(sizeof(*vib_dev), GFP_KERNEL);
if (!vib_dev)
return -ENOMEM;
vib_dev->dev = &pdev->dev;
#endif
printk("[VIBRATOR] tspdrv_probe.!!\n");
#ifdef IMPLEMENT_AS_CHAR_DRIVER
g_nMajor = register_chrdev(0, MODULE_NAME, &fops);
if (g_nMajor < 0)
{
DbgOut((KERN_ERR "tspdrv: can't get major number.\n"));
return g_nMajor;
}
#else
nRet = misc_register(&miscdev);
if (nRet)
{
DbgOut((KERN_ERR "tspdrv: misc_register failed.\n"));
return nRet;
}
#endif
DbgRecorderInit(());
ImmVibeSPI_ForceOut_Initialize();
VibeOSKernelLinuxInitTimer();
/* Get and concatenate device name and initialize data buffer */
g_cchDeviceName = 0;
for (i=0; i<NUM_ACTUATORS; i++)
{
char *szName = g_szDeviceName + g_cchDeviceName;
ImmVibeSPI_Device_GetName(i, szName, VIBE_MAX_DEVICE_NAME_LENGTH);
/* Append version information and get buffer length */
strcat(szName, VERSION_STR);
g_cchDeviceName += strlen(szName);
g_SamplesBuffer[i].nIndexPlayingBuffer = -1; /* Not playing */
g_SamplesBuffer[i].actuatorSamples[0].nBufferSize = 0;
g_SamplesBuffer[i].actuatorSamples[1].nBufferSize = 0;
}
#if !defined(CONFIG_MACH_LGE_L9II_OPEN_EU)
nRet = pm8xxx_vib_read_u8(vib_dev, &val, VIB_DRV);
if (nRet < 0)
goto err_read_vib;
val &= ~VIB_DRV_EN_MANUAL_MASK;
nRet = pm8xxx_vib_write_u8(vib_dev, val, VIB_DRV);
if (nRet < 0)
goto err_read_vib;
vib_dev->reg_vib_drv = val;
return 0;
err_read_vib :
kfree(vib_dev);
return nRet;
#else
return 0;
#endif
}
static int __devinit pm8xxx_vib_probe(struct platform_device *pdev)
{
const struct pm8xxx_vibrator_platform_data *pdata =
pdev->dev.platform_data;
struct pm8xxx_vib *vib;
u8 val;
int rc;
printk("[vibrator] %s ,probe+++++ \n",__func__ );/*Carl Chang*/
if (!pdata)
return -EINVAL;
if (pdata->level_mV < VIB_MIN_LEVEL_mV ||
pdata->level_mV > VIB_MAX_LEVEL_mV)
return -EINVAL;
vib = kzalloc(sizeof(*vib), GFP_KERNEL);
if (!vib)
return -ENOMEM;
vib->pdata = pdata;
vib->level = pdata->level_mV / 100;
vib->dev = &pdev->dev;
//spin_lock_init(&vib->lock);
mutex_init(&vib->lock);
/*Register PM_log*/
#ifdef CONFIG_PM_LOG
vib->pmlog_device = pmlog_register_device(&pdev->dev);
#endif
/*Carl Chang,20120528*/
INIT_WORK(&vib->work, pm8xxx_vib_update);
hrtimer_init(&vib->vib_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
vib->vib_timer.function = pm8xxx_vib_timer_func;
vib->timed_dev.name = "vibrator";
vib->timed_dev.get_time = pm8xxx_vib_get_time;
vib->timed_dev.enable = pm8xxx_vib_enable;
__dump_vib_regs(vib, "boot_vib_default");
/*
* Configure the vibrator, it operates in manual mode
* for timed_output framework.
*/
rc = pm8xxx_vib_read_u8(vib, &val, VIB_DRV);
if (rc < 0)
goto err_read_vib;
val &= ~VIB_DRV_EN_MANUAL_MASK;
rc = pm8xxx_vib_write_u8(vib, val, VIB_DRV);
if (rc < 0)
goto err_read_vib;
vib->reg_vib_drv = val;
rc = timed_output_dev_register(&vib->timed_dev);
if (rc < 0)
goto err_read_vib;
//pm8xxx_vib_enable(&vib->timed_dev, pdata->initial_vibrate_ms);
// Carl Chang, 20120829, remove initial vibrate
platform_set_drvdata(pdev, vib);
vib_dev = vib;
/* Add for debugfs and fvs mode test */
vibrator_create_debugfs_entries(vib_dev);
vibrator_create_kernel_debuglevel_entries();
/* Emily Jiang, 20120201 */
printk("[vibrator] %s ,probe----- \n",__func__ );/*Carl Chang*/
return 0;
err_read_vib:
kfree(vib);
return rc;
}
static int __devinit pm8xxx_vib_probe(struct platform_device *pdev)
{
struct pm8xxx_vib *vib;
struct input_dev *input_dev;
int error;
u8 val;
vib = kzalloc(sizeof(*vib), GFP_KERNEL);
input_dev = input_allocate_device();
if (!vib || !input_dev) {
dev_err(&pdev->dev, "couldn't allocate memory\n");
error = -ENOMEM;
goto err_free_mem;
}
INIT_WORK(&vib->work, pm8xxx_work_handler);
vib->dev = &pdev->dev;
vib->vib_input_dev = input_dev;
error = pm8xxx_vib_read_u8(vib, &val, VIB_DRV);
if (error < 0)
goto err_free_mem;
val &= ~VIB_DRV_EN_MANUAL_MASK;
error = pm8xxx_vib_write_u8(vib, val, VIB_DRV);
if (error < 0)
goto err_free_mem;
vib->reg_vib_drv = val;
input_dev->name = "pm8xxx_vib_ffmemless";
input_dev->id.version = 1;
input_dev->dev.parent = &pdev->dev;
input_dev->close = pm8xxx_vib_close;
input_set_drvdata(input_dev, vib);
input_set_capability(vib->vib_input_dev, EV_FF, FF_RUMBLE);
error = input_ff_create_memless(input_dev, NULL,
pm8xxx_vib_play_effect);
if (error) {
dev_err(&pdev->dev,
"couldn't register vibrator as FF device\n");
goto err_free_mem;
}
error = input_register_device(input_dev);
if (error) {
dev_err(&pdev->dev, "couldn't register input device\n");
goto err_destroy_memless;
}
platform_set_drvdata(pdev, vib);
return 0;
err_destroy_memless:
input_ff_destroy(input_dev);
err_free_mem:
input_free_device(input_dev);
kfree(vib);
return error;
}
static int __devinit pm8xxx_vib_probe(struct platform_device *pdev)
{
const struct pm8xxx_vibrator_platform_data *pdata =
pdev->dev.platform_data;
struct pm8xxx_vib *vib;
u8 val;
int rc;
if (!pdata)
return -EINVAL;
if (pdata->level_mV < VIB_MIN_LEVEL_mV ||
pdata->level_mV > VIB_MAX_LEVEL_mV)
return -EINVAL;
vib = kzalloc(sizeof(*vib), GFP_KERNEL);
if (!vib)
return -ENOMEM;
vib->pdata = pdata;
vib->level = pdata->level_mV / 100;
vib->dev = &pdev->dev;
spin_lock_init(&vib->lock);
INIT_WORK(&vib->work, pm8xxx_vib_update);
hrtimer_init(&vib->vib_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
vib->vib_timer.function = pm8xxx_vib_timer_func;
vib->timed_dev.name = "vibrator";
vib->timed_dev.get_time = pm8xxx_vib_get_time;
vib->timed_dev.enable = pm8xxx_vib_enable;
__dump_vib_regs(vib, "boot_vib_default");
/*
* Configure the vibrator, it operates in manual mode
* for timed_output framework.
*/
rc = pm8xxx_vib_read_u8(vib, &val, VIB_DRV);
if (rc < 0)
goto err_read_vib;
val &= ~VIB_DRV_EN_MANUAL_MASK;
rc = pm8xxx_vib_write_u8(vib, val, VIB_DRV);
if (rc < 0)
goto err_read_vib;
vib->reg_vib_drv = val;
rc = timed_output_dev_register(&vib->timed_dev);
if (rc < 0)
goto err_read_vib;
/*PERI-AH-VIBRATOR_Add_level_file_node-00+[ */
vib_Level = vib->level;
dev_info(&pdev->dev, "default vib_Level %d \n", vib_Level);
/* Set voltage parameter of vibrator(corresponding to the file node /sys/class/timed_output/vibrator/level) */
rc = device_create_file(vib->timed_dev.dev, &dev_attr_level);
if (rc) {
dev_err(&pdev->dev, "dev_attr_level device_create_file failed\n");
device_remove_file(vib->timed_dev.dev, &dev_attr_level);
}
/*PERI-AH-VIBRATOR_Add_level_file_node-00+[ */
#ifdef INIT_VIB_ENABLE
pm8xxx_vib_enable(&vib->timed_dev, pdata->initial_vibrate_ms);
#endif
platform_set_drvdata(pdev, vib);
vib_dev = vib;
return 0;
err_read_vib:
kfree(vib);
return rc;
}
static int __devinit pm8xxx_vib_probe(struct platform_device *pdev)
{
const struct pm8xxx_vibrator_platform_data *pdata =
pdev->dev.platform_data;
struct pm8xxx_vib *vib;
u8 val;
int rc;
if (!pdata)
return -EINVAL;
if (pdata->level_mV < VIB_MIN_LEVEL_mV ||
pdata->level_mV > VIB_MAX_LEVEL_mV)
return -EINVAL;
vib = kzalloc(sizeof(*vib), GFP_KERNEL);
if (!vib)
return -ENOMEM;
vib->pdata = pdata;
vib->level = pdata->level_mV / 100;
vib->pre_value = 0;
vib->dev = &pdev->dev;
spin_lock_init(&vib->lock);
INIT_WORK(&vib->work, pm8xxx_vib_update);
hrtimer_init(&vib->vib_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
vib->vib_timer.function = pm8xxx_vib_timer_func;
vib->timed_dev.name = "vibrator";
vib->timed_dev.get_time = pm8xxx_vib_get_time;
vib->timed_dev.enable = pm8xxx_vib_enable;
__dump_vib_regs(vib, "boot_vib_default");
/*
* Configure the vibrator, it operates in manual mode
* for timed_output framework.
*/
rc = pm8xxx_vib_read_u8(vib, &val, VIB_DRV);
if (rc < 0)
goto err_read_vib;
val &= ~VIB_DRV_EN_MANUAL_MASK;
rc = pm8xxx_vib_write_u8(vib, val, VIB_DRV);
if (rc < 0)
goto err_read_vib;
vib->reg_vib_drv = val;
rc = timed_output_dev_register(&vib->timed_dev);
if (rc < 0)
goto err_read_vib;
#ifdef CONFIG_LGE_PMIC8XXX_VIBRATOR_VOL
rc = device_create_file(vib->timed_dev.dev, &dev_attr_amp);
if (rc < 0)
goto err_read_vib;
/* no vibration during initialization, [email protected], 01/02/2012 */
//pm8xxx_vib_enable(&vib->timed_dev, pdata->initial_vibrate_ms);
#else
pm8xxx_vib_enable(&vib->timed_dev, pdata->initial_vibrate_ms);
#endif
platform_set_drvdata(pdev, vib);
vib_dev = vib;
return 0;
err_read_vib:
kfree(vib);
return rc;
}
static int __devinit pm8xxx_vib_probe(struct platform_device *pdev)
{
const struct pm8xxx_vibrator_platform_data *pdata =
pdev->dev.platform_data;
struct pm8xxx_vib *vib;
u8 val;
int rc;
int count = 0;
VIB_DEBUG_LOG(KERN_INFO, "called.\n");
if (!pdata) {
VIB_LOG(KERN_ERR, "pdata is NULL\n");
return -EINVAL;
}
if (pdata->level_mV < VIB_MIN_LEVEL_mV ||
pdata->level_mV > VIB_MAX_LEVEL_mV) {
VIB_LOG(KERN_ERR, "level_mV error. level_mV=%d\n",
pdata->level_mV);
return -EINVAL;
}
vib = kzalloc(sizeof(*vib), GFP_KERNEL);
if (!vib) {
VIB_LOG(KERN_ERR, "kzalloc error.\n");
return -ENOMEM;
}
vib->pdata = pdata;
vib->level = pdata->level_mV / 100;
vib->dev = &pdev->dev;
mutex_init(&vib->vib_mutex);
for (count = 0; count < VIB_WORK_NUM; count++) {
INIT_WORK(&(vib->vib_on_work_data[count].work_vib_on),
pm8xxx_vibrator_on);
INIT_WORK(&vib->work_vib_off[count], pm8xxx_vibrator_off);
vib->vib_on_work_data[count].vib_time = 0;
VIB_DEBUG_LOG(KERN_INFO, "vib_on_work_data[%d].vib_time=%d\n", count,
vib->vib_on_work_data[count].vib_time);
}
vib->work_vib_on_pos = 0;
vib->work_vib_off_pos = 0;
hrtimer_init(&vib->vib_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
vib->vib_timer.function = pm8xxx_vib_timer_func;
vib->timed_dev.name = "vibrator";
vib->timed_dev.get_time = pm8xxx_vib_get_time;
vib->timed_dev.enable = pm8xxx_vib_enable;
#ifdef DEBUG_VIB_PM8XXX
__dump_vib_regs(vib, "boot_vib_default");
#endif /* DEBUG_VIB_PM8XXX */
/*
* Configure the vibrator, it operates in manual mode
* for timed_output framework.
*/
rc = pm8xxx_vib_read_u8(vib, &val, VIB_DRV);
if (rc < 0) {
VIB_LOG(KERN_ERR, "pm8xxx_vib_read_u8 error. rc=%d\n", rc);
goto err_read_vib;
}
val &= ~VIB_DRV_EN_MANUAL_MASK;
rc = pm8xxx_vib_write_u8(vib, val, VIB_DRV);
if (rc < 0) {
VIB_LOG(KERN_ERR, "pm8xxx_vib_write_u8 error. rc=%d\n", rc);
goto err_read_vib;
}
vib->reg_vib_drv = val;
rc = timed_output_dev_register(&vib->timed_dev);
if (rc < 0) {
VIB_LOG(KERN_ERR, "timed_output_dev_register error. rc=%d\n", rc);
goto err_read_vib;
}
platform_set_drvdata(pdev, vib);
vib_dev = vib;
VIB_DEBUG_LOG(KERN_INFO, "end.rc=%d\n", 0);
return 0;
err_read_vib:
VIB_DEBUG_LOG(KERN_INFO, "err_read_vib.\n");
kfree(vib);
VIB_DEBUG_LOG(KERN_INFO, "end.rc=%d\n", rc);
return rc;
}
static int __devinit pm8xxx_vib_probe(struct platform_device *pdev)
{
const struct pm8xxx_vibrator_platform_data *pdata =
pdev->dev.platform_data;
struct pm8xxx_vib *vib;
u8 val;
int rc;
if (!pdata)
return -EINVAL;
if (pdata->level_mV < VIB_MIN_LEVEL_mV ||
pdata->level_mV > VIB_MAX_LEVEL_mV)
return -EINVAL;
vib = kzalloc(sizeof(*vib), GFP_KERNEL);
if (!vib)
return -ENOMEM;
vib->pdata = pdata;
vib->level = pdata->level_mV / 100;
vib->dev = &pdev->dev;
#ifdef CONFIG_LGE_PMIC8XXX_VIBRATOR_VOL
vib->default_level = vib->level;
vib->request_level = vib->level;
#endif
#ifdef CONFIG_LGE_PMIC8XXX_VIBRATOR_MIN_TIMEOUT
vib->min_timeout_ms = pdata->min_timeout_ms;
vib->pre_value = 0;
#endif
#ifdef CONFIG_LGE_PMIC8XXX_VIBRATOR_OVERDRIVE
vib->overdrive_ms = pdata->overdrive_ms;
vib->overdrive_range_ms = pdata->overdrive_range_ms;
#endif
#ifdef CONFIG_LGE_PMIC8XXX_VIBRATOR_REST_POWER
vib->min_stop_ms = pdata->min_stop_ms;
vib->start_tv.tv_sec = 0;
vib->start_tv.tv_usec = 0;
vib->stop_tv.tv_sec = 0;
vib->stop_tv.tv_usec = 0;
#endif
vib->max_level_mv = VIB_MAX_LEVEL_mV;
vib->min_level_mv = VIB_MIN_LEVEL_mV;
spin_lock_init(&vib->lock);
INIT_WORK(&vib->work, pm8xxx_vib_update);
hrtimer_init(&vib->vib_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
vib->vib_timer.function = pm8xxx_vib_timer_func;
#ifdef CONFIG_LGE_PMIC8XXX_VIBRATOR_OVERDRIVE
hrtimer_init(&vib->vib_overdrive_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
vib->vib_overdrive_timer.function = pm8xxx_vib_overdrive_timer_func;
#endif
vib->timed_dev.name = "vibrator";
vib->timed_dev.get_time = pm8xxx_vib_get_time;
vib->timed_dev.enable = pm8xxx_vib_enable;
__dump_vib_regs(vib, "boot_vib_default");
/*
* Configure the vibrator, it operates in manual mode
* for timed_output framework.
*/
rc = pm8xxx_vib_read_u8(vib, &val, VIB_DRV);
if (rc < 0)
goto err_read_vib;
val &= ~VIB_DRV_EN_MANUAL_MASK;
rc = pm8xxx_vib_write_u8(vib, val, VIB_DRV);
if (rc < 0)
goto err_read_vib;
vib->reg_vib_drv = val;
rc = timed_output_dev_register(&vib->timed_dev);
if (rc < 0)
goto err_read_vib;
rc = sysfs_create_group(&vib->timed_dev.dev->kobj, &pm8xxx_vib_attr_group);
#if 0
#ifdef CONFIG_LGE_PMIC8XXX_VIBRATOR_VOL
rc = device_create_file(vib->timed_dev.dev, &dev_attr_amp);
if (rc < 0)
goto err_read_vib;
rc = device_create_file(vib->timed_dev.dev, &dev_attr_default_level);
if (rc < 0)
goto err_read_vib;
#endif
// LGE does not use this function. power on vib effect is played at SBL3
#ifndef CONFIG_MACH_LGE
pm8xxx_vib_enable(&vib->timed_dev, pdata->initial_vibrate_ms);
#endif
#ifdef CONFIG_LGE_PMIC8XXX_VIBRATOR_MIN_TIMEOUT
rc = device_create_file(vib->timed_dev.dev, &dev_attr_min_ms);
if (rc < 0)
goto err_read_vib;
#endif
#ifdef CONFIG_LGE_PMIC8XXX_VIBRATOR_OVERDRIVE
rc = device_create_file(vib->timed_dev.dev, &dev_attr_over_ms);
if (rc < 0)
goto err_read_vib;
rc = device_create_file(vib->timed_dev.dev, &dev_attr_over_range_ms);
if (rc < 0)
goto err_read_vib;
#endif
#ifdef CONFIG_LGE_PMIC8XXX_VIBRATOR_REST_POWER
rc = device_create_file(vib->timed_dev.dev, &dev_attr_min_stop_ms);
if (rc < 0)
goto err_read_vib;
#endif
#endif // #if 0
platform_set_drvdata(pdev, vib);
vib_dev = vib;
return 0;
err_read_vib:
kfree(vib);
return rc;
}