int __init tspdrv_init( void )
{
int nRet, i; /* initialized below */
DbgOut((KERN_INFO "tspdrv: init_module. enter\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
nRet = platform_device_register(&platdev);
if (nRet)
{
DbgOut((KERN_ERR "tspdrv: platform_device_register failed.\n"));
}
nRet = platform_driver_register(&platdrv);
if (nRet)
{
DbgOut((KERN_ERR "tspdrv: platform_driver_register failed.\n"));
}
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;
}
DbgOut((KERN_INFO "tspdrv: init_module exit.\n"));
device_create_file(&platdev.dev, &dev_attr_nforce_timed);
ImmVibe_timed_output();
return 0;
}
static int __init tspdrv_init(void)
{
int nRet, i; /* initialized below */
atomic_set(&g_nDebugLevel, DBL_ERROR);
#ifdef VIBE_RUNTIME_RECORD
atomic_set(&g_bRuntimeRecord, 0);
DbgOut((DBL_ERROR, "*** tspdrv: runtime recorder feature is ON for debugging which should be OFF in release version.\n"
"*** tspdrv: please turn off the feature by removing VIBE_RUNTIME_RECODE macro.\n"));
#endif
DbgOut((DBL_INFO, "tspdrv: init_module.\n"));
#ifdef IMPLEMENT_AS_CHAR_DRIVER
g_nMajor = register_chrdev(0, MODULE_NAME, &fops);
if (g_nMajor < 0)
{
DbgOut((DBL_ERROR, "tspdrv: can't get major number.\n"));
return g_nMajor;
}
#else
nRet = misc_register(&miscdev);
if (nRet)
{
DbgOut((DBL_ERROR, "tspdrv: misc_register failed.\n"));
return nRet;
}
#endif
nRet = platform_device_register(&platdev);
if (nRet)
DbgOut((DBL_ERROR, "tspdrv: platform_device_register failed.\n"));
nRet = platform_driver_register(&platdrv);
if (nRet)
DbgOut((DBL_ERROR, "tspdrv: platform_driver_register failed.\n"));
DbgRecorderInit(());
ImmVibeSPI_ForceOut_Initialize();
VibeOSKernelLinuxInitTimer();
ResetOutputData();
/* 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);
}
return 0;
}
int init_module(void)
{
int nRet, i; /* initialized below */
#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
nRet = platform_device_register(&platdev);
if (nRet)
DbgOut((KERN_ERR "tspdrv: platform_device_register failed.\n"));
nRet = platform_driver_register(&platdrv);
if (nRet)
DbgOut((KERN_ERR "tspdrv: platform_driver_register failed.\n"));
nRet = platform_driver_register(&max8997_hapticmotor_driver);
if (nRet)
DbgOut((KERN_ERR "tspdrv: platform_driver_register failed (hapticmotor).\n"));
DbgRecorderInit(());
vibetonz_clk_on(&platdev.dev);
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;
}
wake_lock_init(&vib_wake_lock, WAKE_LOCK_SUSPEND, "vib_present");
vibetonz_start();
return 0;
}
static __devinit int tspdrv_probe(struct platform_device *pdev)
{
int ret, i, rc; /* initialized below */
DbgOut((KERN_INFO "tspdrv: tspdrv_probe.\n"));
motor_min_strength = g_nlra_gp_clk_n*MOTOR_MIN_STRENGTH/100;
if(!pdev->dev.of_node){
DbgOut(KERN_ERR "tspdrv: tspdrv probe failed, DT is NULL");
return -ENODEV;
}
rc = tspdrv_parse_dt(pdev);
if(rc)
return rc;
virt_mmss_gp0_base = ioremap(MSM_MMSS_GP0_BASE,0x28);
if (!virt_mmss_gp0_base)
panic("tspdrv : Unable to ioremap MSM_MMSS_GP0 memory!");
vibrator_drvdata.power_onoff = NULL;
vibrator_drvdata.pwm_dev = NULL;
ret = misc_register(&miscdev);
if (ret) {
DbgOut((KERN_ERR "tspdrv: misc_register failed.\n"));
iounmap(virt_mmss_gp0_base);
return ret;
}
DbgRecorderInit(());
vibetonz_clk_on(&pdev->dev);
ImmVibeSPI_ForceOut_Initialize();
VibeOSKernelLinuxInitTimer();
/* Get and concatenate device name and initialize data buffer */
g_cchdevice_name = 0;
for (i = 0; i < NUM_ACTUATORS; i++) {
char *szName = g_szdevice_name + g_cchdevice_name;
ImmVibeSPI_Device_GetName(i,
szName, VIBE_MAX_DEVICE_NAME_LENGTH);
/* Append version information and get buffer length */
strlcat(szName, VERSION_STR, sizeof(VERSION_STR));
g_cchdevice_name += strnlen(szName, sizeof(szName));
g_samples_buffer[i].nindex_playing_buffer = -1;/* Not playing */
g_samples_buffer[i].actuator_samples[0].nbuffer_size = 0;
g_samples_buffer[i].actuator_samples[1].nbuffer_size = 0;
}
wake_lock_init(&vib_wake_lock, WAKE_LOCK_SUSPEND, "vib_present");
vibetonz_start();
return 0;
}
int init_module(void)
{
int nRet; /* initialized below */
DbgOut((KERN_INFO "vtmdrv: init_module.\n"));
mutex_init(&(timer_state.lock));
timer_state.state = TIMER_DISABLED;
#ifdef IMPLEMENT_AS_CHAR_DRIVER
g_nMajor = register_chrdev(0, MODULE_NAME, &fops);
if (g_nMajor < 0)
{
DbgOut((KERN_ERR "vtmdrv: can't get major number.\n"));
return g_nMajor;
}
#else
nRet = misc_register(&miscdev);
if (nRet)
{
DbgOut((KERN_ERR "vtmdrv: misc_register failed.\n"));
return nRet;
}
#endif
nRet = platform_device_register(&platdev);
if (nRet)
{
DbgOut((KERN_ERR "vtmdrv: platform_device_register failed.\n"));
}
nRet = platform_driver_register(&platdrv);
if (nRet)
{
DbgOut((KERN_ERR "vtmdrv: platform_driver_register failed.\n"));
}
ImmVibeSPI_ForceOut_Initialize();
VibeOSKernelLinuxInitTimer();
/* Get device name */
ImmVibeSPI_Device_GetName(g_szDeviceName, VIBE_MAX_DEVICE_NAME_LENGTH);
/* Append version information and get buffer length */
strcat(g_szDeviceName, VERSION_STR);
g_cchDeviceName = strlen(g_szDeviceName);
return 0;
}
static int immersion_vibrator_probe(struct platform_device *pdev)
{
int nRet, i; /* initialized below */
DbgRecorderInit(());
platform_vibe_data = (struct lge_vibrator_platform_data *)pdev->dev.platform_data;
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;
}
nRet = device_create_file(&pdev->dev, &dev_attr_tspdrv_on);
if (nRet < 0) {
DbgOut((KERN_ERR "tspdrv: device_create_file dev_attr_tspdrv_on failed.\n"));
}
nRet = device_create_file(&pdev->dev, &dev_attr_tspdrv_pwm);
if (nRet < 0) {
DbgOut((KERN_ERR "tspdrv: device_create_file dev_attr_tspdrv_pwm failed.\n"));
}
printk(KERN_INFO "LGE: Immersion tspdrv vibrator probe was done\n");
return 0;
}
int init_module(void)
{
int nRet, i; /* initialized below */
DbgOut((KERN_DEBUG "tspdrv: init_module.\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
nRet = platform_device_register(&platdev);
if (nRet)
{
DbgOut((KERN_ERR "tspdrv: platform_device_register failed.\n"));
}
nRet = platform_driver_register(&platdrv);
if (nRet)
{
DbgOut((KERN_ERR "tspdrv: platform_driver_register failed.\n"));
}
if (IS_ERR_OR_NULL(regulator_motor))
{
regulator_motor = regulator_get(NULL, "vcc_motor");
if (IS_ERR_OR_NULL(regulator_motor))
{
pr_err("failed to get motor regulator");
return -EINVAL;
}
}
if(gpio_is_valid(VIB_EN))
{
gpio_request(VIB_EN, "VIB_EN");
s3c_gpio_cfgpin(VIB_EN, 1);
gpio_set_value(VIB_EN, 0);
s3c_gpio_setpull(VIB_EN, S3C_GPIO_PULL_NONE);
}
if(gpio_is_valid(VIB_PWM))
{
gpio_request(VIB_PWM, "VIB_PWM");
/* s3c_gpio_cfgpin(VIB_PWM, S5PV210_GPD_0_1_TOUT_1); */
s3c_gpio_cfgpin(VIB_PWM, S3C_GPIO_OUTPUT);
gpio_set_value(VIB_PWM, 0);
s3c_gpio_setpull(VIB_PWM, S3C_GPIO_PULL_NONE);
gpio_free(VIB_PWM);
}
INIT_WORK(&work_timer, work_timer_func);
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;
}
wake_lock_init(&vib_wake_lock, WAKE_LOCK_SUSPEND, "vib_present");
#ifdef VIBE_TUNING
// ---------- file creation at '/sys/class/vibetonz/immTest'------------------------------
vibetonz_class = class_create(THIS_MODULE, "vibetonz");
if (IS_ERR(vibetonz_class))
pr_err("Failed to create class(vibetonz)!\n");
immTest_test = device_create(vibetonz_class, NULL, 0, NULL, "immTest");
if (IS_ERR(immTest_test))
pr_err("Failed to create device(switch)!\n");
if (device_create_file(immTest_test, &dev_attr_immTest) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_immTest.attr.name);
#if 0
if (device_create_file(immTest_test, &dev_attr_vib_period) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_vib_period.attr.name);
#endif
#endif
vibetonz_start();
return 0;
}
static __devinit int tspdrv_probe(struct platform_device *pdev)
{
int ret, i, rc; /* initialized below */
DbgOut((KERN_INFO "tspdrv: tspdrv_probe.\n"));
motor_min_strength = g_nlra_gp_clk_n*MOTOR_MIN_STRENGTH/100;
if(!pdev->dev.of_node){
DbgOut(KERN_ERR "tspdrv: tspdrv probe failed, DT is NULL");
return -ENODEV;
}
rc = tspdrv_parse_dt(pdev);
if(rc)
return rc;
#if defined(CONFIG_MACH_HLTEDCM) || defined(CONFIG_MACH_HLTEKDI) || defined(CONFIG_MACH_JS01LTEDCM)
virt_mmss_gp1_base = ioremap(MSM_MMSS_GP3_BASE,0x28);
#elif defined(CONFIG_SEC_BERLUTI_PROJECT) || defined(CONFIG_MACH_S3VE3G_EUR)
virt_mmss_gp1_base = ioremap(MSM_MMSS_GP0_BASE,0x28);
#else
virt_mmss_gp1_base = ioremap(MSM_MMSS_GP1_BASE,0x28);
#endif
if (!virt_mmss_gp1_base)
panic("tspdrv : Unable to ioremap MSM_MMSS_GP1 memory!");
#if defined(CONFIG_MOTOR_DRV_MAX77803) || defined(CONFIG_MOTOR_DRV_MAX77804K) || defined(CONFIG_MOTOR_DRV_MAX77828)
vibrator_drvdata.power_onoff = max77803_haptic_power_onoff;
#else
vibrator_drvdata.power_onoff = NULL;
#endif
vibrator_drvdata.pwm_dev = NULL;
#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"));
ret = g_nmajor;
iounmap(virt_mmss_gp1_base);
return ret;
}
#else
ret = misc_register(&miscdev);
if (ret) {
DbgOut((KERN_ERR "tspdrv: misc_register failed.\n"));
iounmap(virt_mmss_gp1_base);
return ret;
}
#endif
DbgRecorderInit(());
vibetonz_clk_on(&pdev->dev);
ImmVibeSPI_ForceOut_Initialize();
VibeOSKernelLinuxInitTimer();
/* Get and concatenate device name and initialize data buffer */
g_cchdevice_name = 0;
for (i = 0; i < NUM_ACTUATORS; i++) {
char *szName = g_szdevice_name + g_cchdevice_name;
ImmVibeSPI_Device_GetName(i,
szName, VIBE_MAX_DEVICE_NAME_LENGTH);
/* Append version information and get buffer length */
strlcat(szName, VERSION_STR, sizeof(VERSION_STR));
g_cchdevice_name += strnlen(szName, sizeof(szName));
g_samples_buffer[i].nindex_playing_buffer = -1;/* Not playing */
g_samples_buffer[i].actuator_samples[0].nbuffer_size = 0;
g_samples_buffer[i].actuator_samples[1].nbuffer_size = 0;
}
wake_lock_init(&vib_wake_lock, WAKE_LOCK_SUSPEND, "vib_present");
vibetonz_start();
vib_dev = device_create(sec_class, NULL, 0, NULL, "vib");
if (IS_ERR(vib_dev)) {
pr_info("Failed to create device for samsung vib\n");
}
ret = sysfs_create_file(&vib_dev->kobj, &dev_attr_vib_tuning.attr);
if (ret) {
pr_info("Failed to create sysfs group for samsung specific led\n");
}
return 0;
}
int init_module(void)
{
int nRet, i; /* initialized below */
int ret = 0;
/*Initialising vibrator spin_lock and mutex_lock*/
spin_lock_init(&vib_spin_lock);
mutex_init(&vib_mut_lock);
DbgOut((KERN_INFO "tspdrv: init_module.\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
nRet = platform_device_register(&platdev);
if (nRet)
{
DbgOut((KERN_ERR "tspdrv: platform_device_register failed.\n"));
}
nRet = platform_driver_register(&platdrv);
if (nRet)
{
DbgOut((KERN_ERR "tspdrv: platform_driver_register failed.\n"));
}
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;
}
wake_lock_init(&vib_wakelock,WAKE_LOCK_SUSPEND,"vib_wakelock");
#ifdef VIBE_TUNING
// ---------- file creation at '/sys/class/vibetonz/immTest'------------------------------
vibetonz_class = class_create(THIS_MODULE, "vibetonz");
if (IS_ERR(vibetonz_class))
pr_err("Failed to create class(vibetonz)!\n");
immTest_test = device_create(vibetonz_class, NULL, 0, NULL, "immTest");
if (IS_ERR(immTest_test))
pr_err("Failed to create device(switch)!\n");
if (device_create_file(immTest_test, &dev_attr_immTest) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_immTest.attr.name);
#endif
if((ret=vibetonz_start()) < 0)
printk("[VIBETONZ] vibetonz_start failed \n");
return 0;
}
static __devinit int tspdrv_probe(struct platform_device *pdev)
{
struct vibrator_platform_data *pdata;
int ret, i; /* initialized below */
DbgOut((KERN_INFO "tspdrv: tspdrv_probe.\n"));
/* This condition will be removed,after all board files changes done */
if (pdev->dev.platform_data == NULL) {
DbgOut(KERN_ERR "tspdrv: tspdrv probe failed, pdata is NULL");
return -EINVAL;
} else {
pdata = pdev->dev.platform_data;
vibrator_drvdata.vib_model = pdata->vib_model;
vibrator_drvdata.is_pmic_haptic_pwr_en = \
pdata->is_pmic_haptic_pwr_en;
if (pdata->vib_model == HAPTIC_PWM) {
if (pdata->is_pmic_vib_pwm)
vibrator_drvdata.vib_pwm_gpio = \
PM8921_GPIO_PM_TO_SYS(pdata->vib_pwm_gpio);
else
vibrator_drvdata.vib_pwm_gpio =
pdata->vib_pwm_gpio;
}
vibrator_drvdata.power_onoff = pdata->power_onoff;
}
#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"));
ret = g_nmajor;
return ret;
}
#else
ret = misc_register(&miscdev);
if (ret) {
DbgOut((KERN_ERR "tspdrv: misc_register failed.\n"));
return ret;
}
#endif
DbgRecorderInit(());
vibetonz_clk_on(&pdev->dev);
ImmVibeSPI_ForceOut_Initialize();
VibeOSKernelLinuxInitTimer();
/* Get and concatenate device name and initialize data buffer */
g_cchdevice_name = 0;
for (i = 0; i < NUM_ACTUATORS; i++) {
char *szName = g_szdevice_name + g_cchdevice_name;
ImmVibeSPI_Device_GetName(i,
szName, VIBE_MAX_DEVICE_NAME_LENGTH);
/* Append version information and get buffer length */
strlcat(szName, VERSION_STR, sizeof(VERSION_STR));
g_cchdevice_name +=
strnlen(szName, (VIBE_MAX_DEVICE_NAME_LENGTH+VERSION_STR_LEN)*NUM_ACTUATORS);
g_samples_buffer[i].nindex_playing_buffer = -1;/* Not playing */
g_samples_buffer[i].actuator_samples[0].nbuffer_size = 0;
g_samples_buffer[i].actuator_samples[1].nbuffer_size = 0;
}
wake_lock_init(&vib_wake_lock, WAKE_LOCK_SUSPEND, "vib_present");
vibetonz_start();
return 0;
}
static __devinit int tspdrv_probe(struct platform_device *pdev)
{
struct vibrator_platform_data *pdata;
int ret, i; /* initialized below */
struct device *sec_vibetonz;
DbgOut((KERN_INFO "tspdrv: tspdrv_probe.\n"));
/* This condition will be removed,after all board files changes done */
if (unlikely(pdev->dev.platform_data == NULL)) {
DbgOut((KERN_ERR "tspdrv: can't get platform data.\n"));
ret = -ENODATA;
goto platform_data_err;
} else {
pdata = pdev->dev.platform_data;
vibrator_drvdata.vib_en_gpio = \
pdata->vib_en_gpio;
vibrator_drvdata.vib_pwm_gpio = pdata->vib_pwm_gpio;
vibrator_drvdata.vib_pwm_gpio = \
pdata->vib_pwm_gpio;
g_nlra_gp_clk_PreDiv = pdata->vib_pwm_PreDiv;
g_nlra_gp_clk_m = pdata->vib_pwm_M;
g_nlra_gp_clk_n = pdata->vib_pwm_N;
g_nlra_gp_clk_d = pdata->vib_pwm_D;
}
#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"));
ret = g_nmajor;
goto register_err;
}
#else
ret = misc_register(&miscdev);
if (ret) {
DbgOut((KERN_ERR "tspdrv: misc_register failed.\n"));
goto register_err;
}
#endif
DbgRecorderInit(());
vibetonz_clk_on(&pdev->dev);
ImmVibeSPI_ForceOut_Initialize();
VibeOSKernelLinuxInitTimer();
/* Get and concatenate device name and initialize data buffer */
g_cchdevice_name = 0;
for (i = 0; i < NUM_ACTUATORS; i++) {
char *szName = g_szdevice_name + g_cchdevice_name;
ImmVibeSPI_Device_GetName(i,
szName, VIBE_MAX_DEVICE_NAME_LENGTH);
/* Append version information and get buffer length */
strncat(szName, VERSION_STR, sizeof(VERSION_STR));
g_cchdevice_name += strnlen(szName, sizeof(szName));
g_samples_buffer[i].nindex_playing_buffer = -1;/* Not playing */
g_samples_buffer[i].actuator_samples[0].nbuffer_size = 0;
g_samples_buffer[i].actuator_samples[1].nbuffer_size = 0;
}
wake_lock_init(&vib_wake_lock, WAKE_LOCK_SUSPEND, "vib_present");
vib_clk = clk_get(&pdev->dev, "core_clk");
if (IS_ERR(vib_clk))
printk(KERN_INFO "[VIB] android vib clk failed!!!\n");
else
printk(KERN_INFO "[VIB] android vib clk is successful\n");
sec_vibetonz = device_create(sec_class, NULL, 0, NULL, "sec_vibetonz");
device_create_file(sec_vibetonz, &dev_attr_MND_M);
device_create_file(sec_vibetonz, &dev_attr_MND_N);
device_create_file(sec_vibetonz, &dev_attr_MND_D);
device_create_file(sec_vibetonz, &dev_attr_MND_P);
device_create_file(sec_vibetonz, &dev_attr_MND_SET);
device_create_file(sec_vibetonz, &dev_attr_MND_CLK);
vibetonz_start();
return 0;
register_err:
#ifdef IMPLEMENT_AS_CHAR_DRIVER
unregister_chrdev(g_nmajor, MODULE_NAME);
#else
misc_deregister(&miscdev);
#endif
platform_data_err:
return ret;
}
int __init tspdrv_init(void)
{
int nRet, i; /* initialized below */
int err;
DbgOut((KERN_INFO "tspdrv: init_module.\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
nRet = platform_device_register(&platdev);
if (nRet)
{
DbgOut((KERN_ERR "tspdrv: platform_device_register failed.\n"));
}
nRet = platform_driver_register(&platdrv);
if (nRet)
{
DbgOut((KERN_ERR "tspdrv: platform_driver_register failed.\n"));
}
/* LGE_CHANGED_START
* Vibrator on/off device file is added(vib_enable)
* 2012.11.11, [email protected]
*/
for (i = 0; i < ARRAY_SIZE(immersion_device_attrs); i++) {
err = device_create_file(miscdev.this_device, &immersion_device_attrs[i]);
if (err)
return err;
}
/* LGE_CHANGED_END 2012.11.11, [email protected] */
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;
}
return 0;
}
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 drv2604_vibrator_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int nRet, i,error; /* initialized below */
char status;
#if SKIP_AUTOCAL == 0
int nCalibrationCount = 0;
#endif
DbgOut((KERN_INFO "tspdrv: Probe called.\n"));
vibrator_drvdata.client = client;
if(!(client->dev.of_node)){
DbgOut(KERN_ERR "tspdrv: tspdrv probe failed, DT is NULL");
return -ENODEV;
}
error = drv2604_parse_dt(&client->dev);
if (error)
return error;
if( gpio_request(vibrator_drvdata.motor_en, "MOTOR_EN") < 0)
{
return -EINVAL;
}
gpio_direction_output(vibrator_drvdata.motor_en, 0);
gpio_export(vibrator_drvdata.motor_en, 0);
nRet = misc_register(&miscdev);
if (nRet)
{
DbgOut((KERN_ERR "tspdrv: misc_register failed.\n"));
return nRet;
}
#if USE_DRV2604_EN_PIN
drv2604_set_en(true);
#endif
#if USE_DRV2604_STANDBY
/* Wait 1000 us for chip power to stabilize */
usleep_range(100000, 100000);
drv2604_change_mode(MODE_DEVICE_READY);
#endif
/* Wait 1000 us for chip power to stabilize */
usleep_range(1000, 1000);
#if SKIP_AUTOCAL
usleep_range(100000, 100000);
drv2604_write_reg_val(init_sequence, sizeof(init_sequence));
status = drv2604_read_reg(STATUS_REG);
#else
/* Run auto-calibration */
do{
drv2604_write_reg_val(autocal_sequence, sizeof(autocal_sequence));
/* Wait until the procedure is done */
drv2604_poll_go_bit();
/* Read status */
status = drv2604_read_reg(STATUS_REG);
nCalibrationCount++;
} while (((status & DIAG_RESULT_MASK) == AUTO_CAL_FAILED) && (nCalibrationCount < MAX_AUTOCALIBRATION_ATTEMPT));
/* Check result */
if ((status & DIAG_RESULT_MASK) == AUTO_CAL_FAILED)
{
DbgOut((DBL_ERROR, "drv2604 auto-calibration failed after %d attempts.\n", nCalibrationCount));
}
else
{
/* Read calibration results */
drv2604_read_reg(AUTO_CALI_RESULT_REG);
drv2604_read_reg(AUTO_CALI_BACK_EMF_RESULT_REG);
drv2604_read_reg(FEEDBACK_CONTROL_REG);
}
#endif
/* Read device ID */
g_nDeviceID = (status & DEV_ID_MASK);
switch (g_nDeviceID)
{
case DRV2605:
DbgOut((DBL_INFO, "drv2604 driver found: drv2605.\n"));
break;
case DRV2604:
DbgOut((DBL_INFO, "drv2604 driver found: drv2604.\n"));
break;
case DRV2604L:
DbgOut((DBL_INFO, "drv2604 driver found: drv2604L.\n"));
break;
case DRV2605L:
DbgOut((DBL_INFO, "drv2604 driver found: drv2605L.\n"));
break;
default:
DbgOut((DBL_INFO, "drv2604 driver found: unknown.\n"));
break;
}
#if USE_DRV2604_STANDBY
/* Put hardware in standby */
drv2604_change_mode(MODE_STANDBY);
#elif USE_DRV2604_EN_PIN
/* enable RTP mode that will be toggled on/off with EN pin */
#endif
#if USE_DRV2604_EN_PIN
/* turn off chip */
drv2604_set_en(false);
#endif
DbgRecorderInit(());
ImmVibeSPI_ForceOut_Initialize();
VibeOSKernelLinuxInitTimer();
ResetOutputData();
/* 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);
}
vibetonz_start();
return 0;
}
static __devinit int tspdrv_tsp5000_probe(struct platform_device *pdev)
{
int ret = 0, i; /* initialized below */
DbgOut((KERN_INFO "tspdrv: tspdrv_tsp5000_probe.\n"));
atomic_set(&g_nDebugLevel, DBL_ERROR);
if(!pdev->dev.of_node){
DbgOut(KERN_ERR "tspdrv_tsp5000: tspdrv_tsp5000 probe failed, DT is NULL");
return -ENODEV;
}
ret = tspdrv_tsp5000_parse_dt(pdev);
if(ret)
return ret;
vibrator_tsp5000_drvdata.power_onoff = NULL;
#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
ret = misc_register(&miscdev);
if (ret)
{
DbgOut((KERN_ERR "tspdrv: misc_register failed.\n"));
goto fail;
}
#endif
DbgRecorderInit(());
vibetonz_ts2665_clk_on(&pdev->dev);
ImmVibeSPI_ForceOut_Initialize();
VibeOSKernelLinuxInitTimer();
ResetOutputData();
/* 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 */
strlcat(szName, VERSION_STR, sizeof(VERSION_STR));
g_cchDeviceName += strnlen(szName, sizeof(szName));
}
wake_lock_init(&vib_wake_lock, WAKE_LOCK_SUSPEND, "vib_present");
vibetonz_start();
return 0;
fail:
return ret;
}
int init_module(void)
{
int nRet, i; /* initialized below */
static struct regulator *l3;
int rc = 0;
DbgOut((KERN_INFO "tspdrv: init_module.\n"));
nRet = misc_register(&miscdev);
printk("[VIBETONZ:WJYOO] MISC_REGISTER nRet = %d\n", nRet);
if (nRet)
{
DbgOut((KERN_ERR "tspdrv: misc_register failed.\n"));
return nRet;
}
nRet = platform_device_register(&platdev);
if (nRet)
{
DbgOut((KERN_ERR "tspdrv: platform_device_register failed.\n"));
}
android_vib_clk = clk_get(NULL,"sfpb_clk");
if(IS_ERR(android_vib_clk)) {
printk("android vib clk failed!!!\n");
} else {
printk("THNAK YOU!!\n");
}
#if defined (CONFIG_KOR_MODEL_SHV_E110S)
if (get_hw_rev() > 0x00 ){
nRet = i2c_add_driver(&vibrator_i2c_driver);
if (nRet)
pr_err("%s: i2c_add_driver() failed err = %d\n", __func__, nRet);
}
#elif defined (CONFIG_KOR_MODEL_SHV_E120L) || defined(CONFIG_KOR_MODEL_SHV_E120K) || defined(CONFIG_KOR_MODEL_SHV_E120S) || defined(CONFIG_KOR_MODEL_SHV_E160S) || defined(CONFIG_KOR_MODEL_SHV_E160K) || defined(CONFIG_KOR_MODEL_SHV_E160L)
nRet = i2c_add_driver(&vibrator_i2c_driver);
if (nRet)
pr_err("%s: i2c_add_driver() failed err = %d\n", __func__, nRet);
#elif defined (CONFIG_USA_MODEL_SGH_T989)|| defined (CONFIG_USA_MODEL_SGH_I727) || defined (CONFIG_USA_MODEL_SGH_T769)
if (get_hw_rev() > 0x04 ){
nRet = i2c_add_driver(&vibrator_i2c_driver);
if (nRet)
pr_err("%s: i2c_add_driver() failed err = %d\n", __func__, nRet);
}
#elif defined (CONFIG_USA_MODEL_SGH_I717) || defined(CONFIG_USA_MODEL_SGH_I757) || defined(CONFIG_USA_MODEL_SGH_I577) || defined(CONFIG_CAN_MODEL_SGH_I577R) || defined(CONFIG_CAN_MODEL_SGH_I757M)
nRet = i2c_add_driver(&vibrator_i2c_driver);
if (nRet) {
pr_err("%s: i2c_add_driver() failed err = %d\n", __func__, nRet);
}
#elif defined (CONFIG_JPN_MODEL_SC_03D)
if (get_hw_rev() >= 0x01 ){
nRet = i2c_add_driver(&vibrator_i2c_driver);
if (nRet)
pr_err("%s: i2c_add_driver() failed err = %d\n", __func__, nRet);
}
#endif
ImmVibeSPI_ForceOut_Initialize();
VibeOSKernelLinuxInitTimer();
platform_driver_register(&platdrv);
isa1200_enabled = 1;
/* 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;
}
//wake_lock_init(&vib_wake_lock, WAKE_LOCK_SUSPEND, "vib_present");
#ifdef VIBE_TUNING
// ---------- file creation at '/sys/class/vibetonz/immTest'------------------------------
vibetonz_class = class_create(THIS_MODULE, "vibetonz");
if (IS_ERR(vibetonz_class))
pr_err("Failed to create class(vibetonz)!\n");
immTest_test = device_create(vibetonz_class, NULL, 0, NULL, "immTest");
if (IS_ERR(immTest_test))
pr_err("Failed to create device(switch)!\n");
if (device_create_file(immTest_test, &dev_attr_immTest) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_immTest.attr.name);
#endif
vibetonz_start();
return 0;
}
static int __devinit isa1200_vibrator_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int nRet, i,error; /* initialized below */
DbgOut((KERN_INFO "tspdrv: Probe called.\n"));
motor_min_strength = g_nlra_gp_clk_n*MOTOR_MIN_STRENGTH/100;
vibrator_drvdata.client = client;
if(!(client->dev.of_node)){
DbgOut(KERN_ERR "tspdrv: tspdrv probe failed, DT is NULL");
return -ENODEV;
}
error = isa1200_parse_dt(&client->dev);
if (error)
return error;
gpio_request(vibrator_drvdata.motor_en, "MOTOR_EN");
gpio_direction_output(vibrator_drvdata.motor_en, 0);
gpio_export(vibrator_drvdata.motor_en, 0);
virt_mmss_gp1_base = ioremap(MSM_MMSS_GP1_BASE,0x28);
if (!virt_mmss_gp1_base)
panic("tspdrv : Unable to ioremap MSM_MMSS_GP1 memory!");
#if defined(CONFIG_MACH_MATISSE3G_OPEN) || defined CONFIG_SEC_MATISSELTE_COMMON
vibrator_drvdata.power_onoff = haptic_power_onoff;
#endif
nRet = misc_register(&miscdev);
if (nRet)
{
DbgOut((KERN_ERR "tspdrv: misc_register failed.\n"));
iounmap(virt_mmss_gp1_base);
return nRet;
}
DbgRecorderInit(());
ImmVibeSPI_ForceOut_Initialize();
VibeOSKernelLinuxInitTimer();
isa1200_enabled = 1;
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;
}
wake_lock_init(&vib_wake_lock, WAKE_LOCK_SUSPEND, "vib_present");
vibetonz_start();
return 0;
}
int init_module(void)
{
int nRet, i; /* initialized below */
DbgOut((KERN_INFO "tspdrv: init_module.\n"));
nRet = misc_register(&miscdev);
printk("[VIBETONZ:WJYOO] MISC_REGISTER nRet = %d\n", nRet);
if (nRet)
{
DbgOut((KERN_ERR "tspdrv: misc_register failed.\n"));
return nRet;
}
nRet = platform_device_register(&platdev);
if (nRet)
{
DbgOut((KERN_ERR "tspdrv: platform_device_register failed.\n"));
}
//android_vib_clk = clk_get(NULL,"sfpb_clk");
android_vib_clk = clk_get_sys("vibrator","core_clk");
if(IS_ERR(android_vib_clk)) {
printk("android vib clk failed!!!\n");
} else {
printk("THNAK YOU!!\n");
}
#if defined (CONFIG_KOR_MODEL_SHV_E110S)
if (get_hw_rev() > 0x00 ){
nRet = i2c_add_driver(&vibrator_i2c_driver);
if (nRet)
pr_err("%s: i2c_add_driver() failed err = %d\n", __func__, nRet);
}
#elif defined (CONFIG_KOR_MODEL_SHV_E120L) || defined(CONFIG_KOR_MODEL_SHV_E120K) || defined(CONFIG_KOR_MODEL_SHV_E120S) || defined(CONFIG_KOR_MODEL_SHV_E160S) || defined(CONFIG_KOR_MODEL_SHV_E160K) || defined(CONFIG_KOR_MODEL_SHV_E160L)
nRet = i2c_add_driver(&vibrator_i2c_driver);
if (nRet)
pr_err("%s: i2c_add_driver() failed err = %d\n", __func__, nRet);
#elif defined (CONFIG_USA_MODEL_SGH_T989)|| defined (CONFIG_USA_MODEL_SGH_I727) || defined (CONFIG_USA_MODEL_SGH_T769)
if (get_hw_rev() > 0x04 ){
nRet = i2c_add_driver(&vibrator_i2c_driver);
if (nRet)
pr_err("%s: i2c_add_driver() failed err = %d\n", __func__, nRet);
}
#elif defined (CONFIG_USA_MODEL_SGH_I717) || defined(CONFIG_USA_MODEL_SGH_I757) || defined(CONFIG_USA_MODEL_SGH_I577)
nRet = i2c_add_driver(&vibrator_i2c_driver);
if (nRet) {
pr_err("%s: i2c_add_driver() failed err = %d\n", __func__, nRet);
}
#elif defined (CONFIG_JPN_MODEL_SC_03D)
if (get_hw_rev() >= 0x01 ){
nRet = i2c_add_driver(&vibrator_i2c_driver);
if (nRet)
pr_err("%s: i2c_add_driver() failed err = %d\n", __func__, nRet);
}
#endif
DbgRecorderInit(());
ImmVibeSPI_ForceOut_Initialize();
VibeOSKernelLinuxInitTimer();
isa1200_enabled = 1;
platform_driver_register(&platdrv);
/* 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;
}
vibetonz_start();
// wake_lock_init(&vib_wake_lock, WAKE_LOCK_SUSPEND, "vib_present");
return 0;
// return nRet;
}
static int __init tspdrv_init(void)
{
int nRet, i; /* initialized below */
atomic_set(&g_nDebugLevel, DBL_ERROR);
#ifdef VIBE_RUNTIME_RECORD
atomic_set(&g_bRuntimeRecord, 0);
DbgOut((DBL_ERROR, "*** tspdrv: runtime recorder feature is ON for debugging which should be OFF in release version.\n"
"*** tspdrv: please turn off the feature by removing VIBE_RUNTIME_RECODE macro.\n"));
#endif
DbgOut((DBL_INFO, "tspdrv: init_module.\n"));
#ifdef IMPLEMENT_AS_CHAR_DRIVER
g_nMajor = register_chrdev(0, MODULE_NAME, &fops);
if (g_nMajor < 0)
{
DbgOut((DBL_ERROR, "tspdrv: can't get major number.\n"));
return g_nMajor;
}
#else
nRet = misc_register(&miscdev);
if (nRet)
{
DbgOut((DBL_ERROR, "tspdrv: misc_register failed.\n"));
return nRet;
}
#endif
nRet = platform_device_register(&platdev);
if (nRet)
{
DbgOut((DBL_ERROR, "tspdrv: platform_device_register failed.\n"));
}
nRet = platform_driver_register(&platdrv);
if (nRet)
{
DbgOut((DBL_ERROR, "tspdrv: platform_driver_register failed.\n"));
}
DbgRecorderInit(());
ImmVibeSPI_ForceOut_Initialize();
VibeOSKernelLinuxInitTimer();
ResetOutputData();
/* 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);
}
#if defined (CONFIG_DEBUG_FS) && defined (CONFIG_TSPDRV_HISTORY)
{
tspdrv_debugfs_dir = kzalloc(sizeof(struct dentry), GFP_KERNEL);
if (!tspdrv_debugfs_dir)
return -ENOMEM;
tspdrv_debugfs_dir =
debugfs_create_dir("tspdrv_debug", NULL);
if (tspdrv_debugfs_dir) {
if (!debugfs_create_file("tspdrv_history", 0644,
tspdrv_debugfs_dir,
NULL, &tspdrv_debugfs_fops))
pr_err("%s : debugfs_create_file, error\n", __func__);
} else
pr_err("%s : debugfs_create_dir, error\n", __func__);
}
#endif
return 0;
}
static int vibrator_probe(struct platform_device *pdev)
{
int nRet, i; /* initialized below */
struct pwm_vibrator_platform_data *pdata = pdev->dev.platform_data;
struct pwm_vib_data *data;
DbgOut((KERN_DEBUG "tspdrv: %s\n", __func__));
data = kzalloc(sizeof(struct pwm_vib_data), GFP_KERNEL);
if (!data) {
dev_err(&pdev->dev, "tspdrv: %s: no memory\n", __func__);
return -ENOMEM;
}
/* LGE_SJIT 2011-12-01 [[email protected]]
* To make it as platform-independent driver
*/
pwm_priv = data;
if (pdata) {
data->power = pdata->power;
data->gpio_enable = pdata->gpio_enable;
data->pwm_port = pdata->port;
data->pwm_freq = pdata->freq;
data->pwm_duty = pdata->duty;
}
if(data->power)
data->power(1);
/* /register a miscellaneous device */
nRet = misc_register(&miscdev);
if (nRet) {
dev_err(&pdev->dev, "tspdrv: %s: misc_register failed\n",
__func__);
goto err_misc_register;
}
DbgRecorderInit(());
/* to set PWM freq, disable amp, etc...*/
ImmVibeSPI_ForceOut_Initialize();//Currently, Timer stats is disabled.
/* 5milliseconds's timer setting!!*/
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;
}
/* LGE_SJIT 2011-11-30 [[email protected]] support for timed output class */
#if defined(CONFIG_TSPDRV_TIMED_OUTPUT)
spin_lock_init(&vibe_lock);
hrtimer_init(&vibe_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
vibe_timer.function = vibrator_timer_func;
timed_dev.name = "vibrator";
timed_dev.get_time = vibrator_get_time;
timed_dev.enable = vibrator_enable;
nRet = timed_output_dev_register(&timed_dev);
if (nRet < 0) {
dev_err(&pdev->dev, "tspdrv: %s: timed_output_dev_register failed\n", __func__);
goto err_timed_output_dev_register;
}
#endif
platform_set_drvdata(pdev, data);
dev_info(&pdev->dev, "tspdrv: probed\n");
return 0;
/* LGE_SJIT 2011-11-30 [[email protected]] support for timed output class */
#if defined(CONFIG_TSPDRV_TIMED_OUTPUT)
timed_output_dev_unregister(&timed_dev);
err_timed_output_dev_register:
hrtimer_cancel(&vibe_timer);
#endif
DbgRecorderTerminate(());
VibeOSKernelLinuxTerminateTimer();
ImmVibeSPI_ForceOut_Terminate();
misc_deregister(&miscdev);
err_misc_register:
kfree(data);
return nRet;
}
int init_module(void)
{
int nRet, i; /* initialized below */
nRet = 0;
#ifdef IMPLEMENT_AS_CHAR_DRIVER
printk(KERN_ERR
"[VIBRATOR]IMPLEMENT_AS_CHAR_DRIVER\n");
g_nMajor = register_chrdev(0, MODULE_NAME, &fops);
if (g_nMajor < 0) {
printk(KERN_ERR"[VIBRATOR]tspdrv: can't get major number.\n");
return g_nMajor;
}
#else
nRet = misc_register(&miscdev);
if (nRet) {
printk(KERN_ERR "[VIBRATOR]tspdrv: misc_register failed.\n");
return nRet;
}
#endif
nRet = platform_device_register(&platdev);
if (nRet) {
printk(KERN_ERR "tspdrv: platform_device_register failed.\n");
goto err_platform_dev_reg;
}
nRet = platform_driver_register(&platdrv);
if (nRet) {
printk(KERN_ERR "tspdrv: platform_driver_register failed.\n");
goto err_platform_drv_reg;
}
DbgRecorderInit(());
vibetonz_clk_on(&platdev.dev);
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;
}
wake_lock_init(&vib_wake_lock, WAKE_LOCK_SUSPEND, "vib_present");
#ifdef CONFIG_FEATURE_TGS2
if (device_create_file(&platdev.dev, &dev_attr_vibrator_level_max) < 0) {
printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_vibrator_level_max.attr.name);
}
if (device_create_file(&platdev.dev, &dev_attr_vibrator_level) < 0) {
printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_vibrator_level.attr.name);
}
#endif
return 0;
err_platform_drv_reg:
platform_device_unregister(&platdev);
err_platform_dev_reg:
#ifdef IMPLEMENT_AS_CHAR_DRIVER
unregister_chrdev(g_nMajor, MODULE_NAME);
#else
misc_deregister(&miscdev);
#endif
return nRet;
}
static __devinit int tspdrv_probe(struct platform_device *pdev)
{
struct vibrator_platform_data *pdata;
int ret, i; /* initialized below */
DbgOut((KERN_INFO "tspdrv: tspdrv_probe.\n"));
/* This condition will be removed,after all board files changes done */
if (pdev->dev.platform_data == NULL) {
vibrator_drvdata.is_pmic_vib_en = 0;
#if defined(CONFIG_MACH_M2_ATT) || defined(CONFIG_MACH_M2_VZW) || \
defined(CONFIG_MACH_M2_SPR) || defined(CONFIG_MACH_M2_DCM) || \
defined(CONFIG_MACH_M2_SKT) || defined(CONFIG_MACH_JAGUAR) || \
defined(CONFIG_MACH_AEGIS2) || defined(CONFIG_MACH_COMANCHE)
vibrator_drvdata.vib_pwm_gpio = GPIO_VIB_PWM;
vibrator_drvdata.vib_en_gpio = GPIO_VIB_ON;
vibrator_drvdata.haptic_pwr_en_gpio = GPIO_HAPTIC_PWR_EN;
vibrator_drvdata.vib_model = HAPTIC_PWM;
#endif
#if defined(CONFIG_MACH_APEXQ) || defined(CONFIG_MACH_JASPER) || \
defined(CONFIG_MACH_GOGH) || defined(CONFIG_MACH_ESPRESSO_ATT)
vibrator_drvdata.vib_pwm_gpio = GPIO_MOTOR_EN;
vibrator_drvdata.vib_en_gpio = GPIO_MOTOR_EN;
vibrator_drvdata.haptic_pwr_en_gpio = GPIO_MOTOR_EN;
vibrator_drvdata.vib_model = HAPTIC_MOTOR;
#endif
#ifdef CONFIG_MACH_M2_ATT
if (system_rev >= BOARD_REV04) {
vibrator_drvdata.vib_en_gpio = PM8921_GPIO_PM_TO_SYS(\
PMIC_GPIO_VIB_ON);
vibrator_drvdata.is_pmic_vib_en = 1;
}
if (system_rev >= BOARD_REV08) {
vibrator_drvdata.haptic_pwr_en_gpio = PM8921_GPIO_PM_TO_SYS(\
PMIC_GPIO_HAPTIC_PWR_EN);
vibrator_drvdata.is_pmic_haptic_pwr_en = 1;
}
#endif
#ifdef CONFIG_MACH_M2_VZW
if (system_rev >= BOARD_REV09) {
vibrator_drvdata.vib_en_gpio = PM8921_GPIO_PM_TO_SYS(\
PMIC_GPIO_VIB_ON);
vibrator_drvdata.is_pmic_vib_en = 1;
}
#endif
#ifdef CONFIG_MACH_M2_SPR
if (system_rev >= BOARD_REV03) {
vibrator_drvdata.vib_en_gpio = PM8921_GPIO_PM_TO_SYS(\
PMIC_GPIO_VIB_ON);
vibrator_drvdata.is_pmic_vib_en = 1;
}
#endif
#ifdef CONFIG_MACH_M2_DCM
if (system_rev >= BOARD_REV01) {
vibrator_drvdata.vib_en_gpio = PM8921_GPIO_PM_TO_SYS(\
PMIC_GPIO_VIB_ON);
vibrator_drvdata.is_pmic_vib_en = 1;
}
#endif
#ifdef CONFIG_MACH_AEGIS2
if (system_rev >= BOARD_REV01) {
vibrator_drvdata.vib_en_gpio = PM8921_GPIO_PM_TO_SYS(\
PMIC_GPIO_VIB_ON);
vibrator_drvdata.is_pmic_vib_en = 1;
}
#endif
} else {
pdata = pdev->dev.platform_data;
vibrator_drvdata.vib_model = pdata->vib_model;
vibrator_drvdata.is_pmic_haptic_pwr_en = \
pdata->is_pmic_haptic_pwr_en;
if (pdata->is_pmic_haptic_pwr_en)
vibrator_drvdata.haptic_pwr_en_gpio = \
PM8921_GPIO_PM_TO_SYS(pdata->haptic_pwr_en_gpio);
else
vibrator_drvdata.haptic_pwr_en_gpio = \
pdata->haptic_pwr_en_gpio;
if (pdata->vib_model == HAPTIC_PWM) {
vibrator_drvdata.vib_pwm_gpio = pdata->vib_pwm_gpio;
vibrator_drvdata.is_pmic_vib_en = \
pdata->is_pmic_vib_en;
if (pdata->is_pmic_vib_en)
vibrator_drvdata.vib_en_gpio = \
PM8921_GPIO_PM_TO_SYS(pdata->vib_en_gpio);
else
vibrator_drvdata.vib_en_gpio = \
pdata->vib_en_gpio;
}
}
#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"));
ret = g_nmajor;
goto register_err;
}
#else
ret = misc_register(&miscdev);
if (ret) {
DbgOut((KERN_ERR "tspdrv: misc_register failed.\n"));
goto register_err;
}
#endif
DbgRecorderInit(());
vibetonz_clk_on(&pdev->dev);
ImmVibeSPI_ForceOut_Initialize();
VibeOSKernelLinuxInitTimer();
/* Get and concatenate device name and initialize data buffer */
g_cchdevice_name = 0;
for (i = 0; i < NUM_ACTUATORS; i++) {
char *szName = g_szdevice_name + g_cchdevice_name;
ImmVibeSPI_Device_GetName(i,
szName, VIBE_MAX_DEVICE_NAME_LENGTH);
/* Append version information and get buffer length */
strncat(szName, VERSION_STR, sizeof(VERSION_STR));
g_cchdevice_name += strnlen(szName, sizeof(szName));
g_samples_buffer[i].nindex_playing_buffer = -1;/* Not playing */
g_samples_buffer[i].actuator_samples[0].nbuffer_size = 0;
g_samples_buffer[i].actuator_samples[1].nbuffer_size = 0;
}
wake_lock_init(&vib_wake_lock, WAKE_LOCK_SUSPEND, "vib_present");
vibetonz_start();
return 0;
register_err:
#ifdef IMPLEMENT_AS_CHAR_DRIVER
unregister_chrdev(g_nmajor, MODULE_NAME);
#else
misc_deregister(&miscdev);
#endif
return ret;
}
int init_module(void)
{
int nRet, i; /* initialized below */
nRet = 0;
if (system_rev < 0x5){
pr_notice("%s : Vibrator not support HW Rev =[%d] !!!\n",__func__,system_rev);
return 0;
}
DbgOut((KERN_INFO "tspdrv: init_module.\n"));
#ifdef IMPLEMENT_AS_CHAR_DRIVER
printk(KERN_ERR
"[VIBRATOR]IMPLEMENT_AS_CHAR_DRIVER\n");
g_nMajor = register_chrdev(0, MODULE_NAME, &fops);
if (g_nMajor < 0) {
printk(KERN_ERR"[VIBRATOR]tspdrv: can't get major number.\n");
return g_nMajor;
}
#else
nRet = misc_register(&miscdev);
if (nRet) {
printk(KERN_ERR "[VIBRATOR]tspdrv: misc_register failed.\n");
return nRet;
}
#endif
nRet = platform_device_register(&platdev);
if (nRet) {
printk(KERN_ERR "tspdrv: platform_device_register failed.\n");
goto err_platform_dev_reg;
}
nRet = platform_driver_register(&platdrv);
if (nRet) {
printk(KERN_ERR "tspdrv: platform_driver_register failed.\n");
goto err_platform_drv_reg;
}
DbgRecorderInit(());
vibetonz_clk_on(&platdev.dev);
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;
}
return 0;
err_platform_drv_reg:
platform_device_unregister(&platdev);
err_platform_dev_reg:
#ifdef IMPLEMENT_AS_CHAR_DRIVER
unregister_chrdev(g_nMajor, MODULE_NAME);
#else
misc_deregister(&miscdev);
#endif
return nRet;
}
