static int __init gps_s5n6420_init(void)
{
int ret = 0;
const char *gps_node = "samsung,lsi_s5n6420";
struct device_node *root_node = NULL;
gps_dev = sec_device_create(NULL, "gps");
BUG_ON(!gps_dev);
root_node = of_find_compatible_node(NULL, NULL, gps_node);
if (!root_node) {
WARN(1, "failed to get device node of ske\n");
ret = -ENODEV;
goto err_sec_device_create;
}
gps_pwr_on = of_get_gpio(root_node, 0);
if (!gpio_is_valid(gps_pwr_on)) {
WARN(1, "----Invalied gpio pin : %d\n", gps_pwr_on);
ret = -ENODEV;
goto err_sec_device_create;
}
gps_reset = of_get_gpio(root_node, 1);
if (!gpio_is_valid(gps_reset)) {
WARN(1, "-----Invalied gpio pin : %d\n", gps_reset);
ret = -ENODEV;
goto err_sec_device_create;
}
if (gpio_request(gps_pwr_on, "GPS_PWR_EN")) {
WARN(1, "fail to request gpio(GPS_PWR_EN)\n");
ret = -ENODEV;
goto err_sec_device_create;
}
if (gpio_request(gps_reset, "GPS_RESET")) {
WARN(1, "fail to request gpio(GPS_RESET)\n");
ret = -ENODEV;
goto err_sec_device_create;
}
gpio_direction_output(gps_pwr_on, 0);
gpio_export(gps_pwr_on, 1);
gpio_export_link(gps_dev, "GPS_PWR_EN", gps_pwr_on);
gpio_direction_output(gps_reset, 1);
gpio_export(gps_reset, 1);
gpio_export_link(gps_dev, "GPS_RESET", gps_reset);
return 0;
err_sec_device_create:
WARN(1, "err_sec_device_create");
sec_device_destroy(gps_dev->devt);
return ret;
}
static int __devexit max77833_haptic_remove(struct platform_device *pdev)
{
struct max77833_haptic_data *data = platform_get_drvdata(pdev);
#ifdef CONFIG_ANDROID_TIMED_OUTPUT
timed_output_dev_unregister(&data->tout_dev);
#endif
sysfs_remove_group(&motor_dev->kobj, &sec_motor_attr_group);
sec_device_destroy(motor_dev->devt);
pwm_free(data->pwm);
destroy_workqueue(data->workqueue);
max77833_haptic_i2c(data, false);
kfree(data);
g_hap_data = NULL;
return 0;
}
static int max77843_rgb_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct max77843_rgb_platform_data *pdata;
struct max77843_rgb *max77843_rgb;
struct max77843_dev *max77843_dev = dev_get_drvdata(dev->parent);
char temp_name[4][40] = {{0,},}, name[40] = {0,}, *p;
int i, ret;
pr_info("leds-max77843-rgb: %s\n", __func__);
#ifdef CONFIG_OF
pdata = max77843_rgb_parse_dt(dev);
if (unlikely(IS_ERR(pdata)))
return PTR_ERR(pdata);
#else
pdata = dev_get_platdata(dev);
#endif
max77843_rgb = devm_kzalloc(dev, sizeof(struct max77843_rgb), GFP_KERNEL);
if (unlikely(!max77843_rgb))
return -ENOMEM;
pr_info("leds-max77843-rgb: %s 1 \n", __func__);
max77843_rgb->i2c = max77843_dev->i2c;
for (i = 0; i < 4; i++) {
ret = snprintf(name, 30, "%s", pdata->name[i])+1;
if (1 > ret)
goto alloc_err_flash;
p = devm_kzalloc(dev, ret, GFP_KERNEL);
if (unlikely(!p))
goto alloc_err_flash;
strcpy(p, name);
strcpy(temp_name[i], name);
max77843_rgb->led[i].name = p;
max77843_rgb->led[i].brightness_set = max77843_rgb_set;
max77843_rgb->led[i].brightness_get = max77843_rgb_get;
max77843_rgb->led[i].max_brightness = LED_MAX_CURRENT;
ret = led_classdev_register(dev, &max77843_rgb->led[i]);
if (IS_ERR_VALUE(ret)) {
dev_err(dev, "unable to register RGB : %d\n", ret);
goto alloc_err_flash_plus;
}
ret = sysfs_create_group(&max77843_rgb->led[i].dev->kobj,
&common_led_attr_group);
if (ret) {
dev_err(dev, "can not register sysfs attribute\n");
goto register_err_flash;
}
}
led_dev = sec_device_create(max77843_rgb, "led");
if (IS_ERR(led_dev)) {
dev_err(dev, "Failed to create device for samsung specific led\n");
goto register_err_flash;
}
ret = sysfs_create_group(&led_dev->kobj, &sec_led_attr_group);
if (ret < 0) {
dev_err(dev, "Failed to create sysfs group for samsung specific led\n");
goto device_create_err;
}
platform_set_drvdata(pdev, max77843_rgb);
#if defined(CONFIG_LEDS_USE_ED28) && defined(CONFIG_SEC_FACTORY)
if( lcdtype == 0 && jig_status == false) {
max77843_rgb_set_state(&max77843_rgb->led[RED], led_dynamic_current, LED_ALWAYS_ON);
}
#endif
lcdtype_color = lcdtype >> 0x10;
if (lcdtype_color == 51)
led_color_dynamic_current = 0x5A;
pr_info("leds-max77843-rgb: %s done\n", __func__);
return 0;
device_create_err:
sec_device_destroy(led_dev->devt);
register_err_flash:
led_classdev_unregister(&max77843_rgb->led[i]);
alloc_err_flash_plus:
devm_kfree(dev, temp_name[i]);
alloc_err_flash:
while (i--) {
led_classdev_unregister(&max77843_rgb->led[i]);
devm_kfree(dev, temp_name[i]);
}
devm_kfree(dev, max77843_rgb);
return -ENOMEM;
}
static int max77833_haptic_probe(struct platform_device *pdev)
{
int error = 0;
struct max77833_dev *max77833 = dev_get_drvdata(pdev->dev.parent);
struct max77833_platform_data *max77833_pdata
= dev_get_platdata(max77833->dev);
struct max77833_haptic_platform_data *pdata
= max77833_pdata->haptic_data;
struct max77833_haptic_data *hap_data;
pr_info("[VIB] ++ %s\n", __func__);
#if defined(CONFIG_OF)
if (pdata == NULL) {
pdata = of_max77833_haptic_dt(&pdev->dev);
if (!pdata) {
pr_err("[VIB] max77833-haptic : %s not found haptic dt!\n",
__func__);
return -1;
}
}
#else
if (pdata == NULL) {
pr_err("[VIB] %s: no pdata\n", __func__);
return -ENODEV;
}
#endif /* CONFIG_OF */
hap_data = kzalloc(sizeof(struct max77833_haptic_data), GFP_KERNEL);
if (!hap_data) {
pr_err("[VIB] %s: no hap_pdata\n", __func__);
kfree(pdata);
return -ENOMEM;
}
platform_set_drvdata(pdev, hap_data);
g_hap_data = hap_data;
hap_data->max77833 = max77833;
hap_data->i2c = max77833->i2c;
hap_data->pdata = pdata;
hap_data->workqueue = create_singlethread_workqueue("hap_work");
if (NULL == hap_data->workqueue) {
error = -EFAULT;
pr_err("[VIB] Failed to create workqueue, err num: %d\n", error);
goto err_work_queue;
}
INIT_WORK(&(hap_data->work), haptic_work);
spin_lock_init(&(hap_data->lock));
hap_data->pwm = pwm_request(hap_data->pdata->pwm_id, "vibrator");
if (IS_ERR(hap_data->pwm)) {
error = -EFAULT;
pr_err("[VIB] Failed to request pwm, err num: %d\n", error);
goto err_pwm_request;
}
pwm_config(hap_data->pwm, pdata->period / 2, pdata->period);
prev_duty = hap_data->pdata->period / 2;
vibetonz_clk_on(&pdev->dev, true);
/* hrtimer init */
hrtimer_init(&hap_data->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
hap_data->timer.function = haptic_timer_func;
/* timed_output_dev init*/
hap_data->tout_dev.name = "vibrator";
hap_data->tout_dev.get_time = haptic_get_time;
hap_data->tout_dev.enable = haptic_enable;
motor_dev = sec_device_create(hap_data, "motor");
if (IS_ERR(motor_dev)) {
error = -ENODEV;
pr_err("[VIB] Failed to create device\
for samsung specific motor, err num: %d\n", error);
goto exit_sec_devices;
}
error = sysfs_create_group(&motor_dev->kobj, &sec_motor_attr_group);
if (error) {
error = -ENODEV;
pr_err("[VIB] Failed to create sysfs group\
for samsung specific motor, err num: %d\n", error);
goto exit_sysfs;
}
#ifdef CONFIG_ANDROID_TIMED_OUTPUT
error = timed_output_dev_register(&hap_data->tout_dev);
if (error < 0) {
error = -EFAULT;
pr_err("[VIB] Failed to register timed_output : %d\n", error);
goto err_timed_output_register;
}
#endif
vibtonz_en = max77833_vibtonz_en;
vibtonz_pwm = max77833_vibtonz_pwm;
prev_temperature_level = 1;
/* autoresonance range setting */
error = max77833_write_reg(hap_data->i2c,
MAX77833_AUTORES_CONFIG, 0x00);
if (error < 0) {
pr_err("[VIB] %s Failed to write REG(0x%02x) [%d]\n",
__func__, MAX77833_AUTORES_CONFIG, error);
}
error = max77833_write_reg(hap_data->i2c,
MAX77833_AUTORES_MIN_FREQ_LOW, pdata->auto_res_min_low);
if (error < 0) {
pr_err("[VIB] %s Failed to write REG(0x%02x) [%d]\n",
__func__, MAX77833_AUTORES_MIN_FREQ_LOW, error);
}
error = max77833_write_reg(hap_data->i2c,
MAX77833_AUTORES_MAX_FREQ_LOW, pdata->auto_res_max_low);
if (error < 0) {
pr_err("[VIB] %s Failed to write REG(0x%02x) [%d]\n",
__func__, MAX77833_AUTORES_MAX_FREQ_LOW, error);
}
error = max77833_write_reg(hap_data->i2c,
MAX77833_AUTORES_INIT_GUESS_LOW, pdata->auto_res_init_low);
if (error < 0) {
pr_err("[VIB] %s Failed to write REG(0x%02x) [%d]\n",
__func__, MAX77833_AUTORES_INIT_GUESS_LOW, error);
}
error = max77833_write_reg(hap_data->i2c,
MAX77833_NOMINAL_STRENGTH, pdata->nominal_strength);
if (error < 0) {
pr_err("[VIB] %s Failed to write REG(0x%02x) [%d]\n",
__func__, MAX77833_NOMINAL_STRENGTH, error);
}
error = max77833_write_reg(hap_data->i2c,
MAX77833_RES_MIN_FREQ_HIGH, pdata->auto_res_min_high);
if (error < 0) {
pr_err("[VIB] %s Failed to write REG(0x%02x) [%d]\n",
__func__, MAX77833_RES_MIN_FREQ_HIGH, error);
}
error = max77833_write_reg(hap_data->i2c,
MAX77833_RES_MAX_FREQ_HIGH, pdata->auto_res_max_high);
if (error < 0) {
pr_err("[VIB] %s Failed to write REG(0x%02x) [%d]\n",
__func__, MAX77833_RES_MAX_FREQ_HIGH, error);
}
error = max77833_write_reg(hap_data->i2c,
MAX77833_AUTORES_INIT_GUESS_HIGH, pdata->auto_res_init_high);
if (error < 0) {
pr_err("[VIB] %s Failed to write REG(0x%02x) [%d]\n",
__func__, MAX77833_AUTORES_INIT_GUESS_HIGH, error);
}
error = max77833_write_reg(hap_data->i2c,
MAX77833_AUTORES_LOCK_WINDOW, pdata->auto_res_lock_window);
if (error < 0) {
pr_err("[VIB] %s Failed to write REG(0x%02x) [%d]\n",
__func__, MAX77833_AUTORES_LOCK_WINDOW, error);
}
error = max77833_write_reg(hap_data->i2c,
MAX77833_AUTORES_UPDATE_FREQ, pdata->auto_res_update_freq);
if (error < 0) {
pr_err("[VIB] %s Failed to write REG(0x%02x) [%d]\n",
__func__, MAX77833_AUTORES_UPDATE_FREQ, error);
}
if (!pdata->auto_res_enable) {
error = max77833_write_reg(hap_data->i2c, MAX77833_OPTION_REG1, 0x11);
if (error < 0) {
pr_err("[VIB] %s Failed to write REG(0x%02x) [%d]\n",
__func__, MAX77833_OPTION_REG1, error);
}
}
return error;
err_timed_output_register:
sysfs_remove_group(&motor_dev->kobj, &sec_motor_attr_group);
exit_sysfs:
sec_device_destroy(motor_dev->devt);
exit_sec_devices:
pwm_free(hap_data->pwm);
err_pwm_request:
destroy_workqueue(hap_data->workqueue);
err_work_queue:
kfree(hap_data);
kfree(pdata);
g_hap_data = NULL;
return error;
}
static int max77843_haptic_probe(struct platform_device *pdev)
{
int error = 0;
struct max77843_dev *max77843 = dev_get_drvdata(pdev->dev.parent);
struct max77843_platform_data *max77843_pdata
= dev_get_platdata(max77843->dev);
struct max77843_haptic_platform_data *pdata
= max77843_pdata->haptic_data;
struct max77843_haptic_data *hap_data;
pr_info("[VIB] ++ %s\n", __func__);
#if defined(CONFIG_OF)
if (pdata == NULL) {
pdata = of_max77843_haptic_dt(&pdev->dev);
if (!pdata) {
pr_err("[VIB] max77843-haptic : %s not found haptic dt!\n",
__func__);
return -1;
}
}
#else
if (pdata == NULL) {
pr_err("%s: no pdata\n", __func__);
return -ENODEV;
}
#endif /* CONFIG_OF */
hap_data = kzalloc(sizeof(struct max77843_haptic_data), GFP_KERNEL);
if (!hap_data) {
kfree(pdata);
return -ENOMEM;
}
platform_set_drvdata(pdev, hap_data);
g_hap_data = hap_data;
hap_data->max77843 = max77843;
hap_data->i2c = max77843->i2c;
hap_data->pdata = pdata;
hap_data->workqueue = create_singlethread_workqueue("hap_work");
if (NULL == hap_data->workqueue) {
error = -EFAULT;
pr_err("[VIB] Failed to create workqueue, err num: %d\n", error);
goto err_work_queue;
}
INIT_WORK(&(hap_data->work), haptic_work);
spin_lock_init(&(hap_data->lock));
hap_data->pwm = pwm_request(hap_data->pdata->pwm_id, "vibrator");
if (IS_ERR(hap_data->pwm)) {
error = -EFAULT;
pr_err("[VIB] Failed to request pwm, err num: %d\n", error);
goto err_pwm_request;
}
pwm_config(hap_data->pwm, pdata->period / 2, pdata->period);
vibetonz_clk_on(&pdev->dev, true);
if (pdata->init_hw)
pdata->init_hw();
else
hap_data->regulator
= regulator_get(NULL, pdata->regulator_name);
if (IS_ERR(hap_data->regulator)) {
error = -EFAULT;
pr_err("[VIB] Failed to get vmoter regulator, err num: %d\n", error);
goto err_regulator_get;
}
/* hrtimer init */
hrtimer_init(&hap_data->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
hap_data->timer.function = haptic_timer_func;
/* timed_output_dev init*/
hap_data->tout_dev.name = "vibrator";
hap_data->tout_dev.get_time = haptic_get_time;
hap_data->tout_dev.enable = haptic_enable;
hap_data->resumed = false;
motor_dev = sec_device_create(hap_data, "motor");
if (IS_ERR(motor_dev)) {
error = -ENODEV;
pr_err("[VIB] Failed to create device\
for samsung specific motor, err num: %d\n", error);
goto exit_sec_devices;
}
error = sysfs_create_group(&motor_dev->kobj, &sec_motor_attr_group);
if (error) {
error = -ENODEV;
pr_err("[VIB] Failed to create sysfs group\
for samsung specific motor, err num: %d\n", error);
goto exit_sysfs;
}
#ifdef CONFIG_ANDROID_TIMED_OUTPUT
error = timed_output_dev_register(&hap_data->tout_dev);
if (error < 0) {
error = -EFAULT;
pr_err("[VIB] Failed to register timed_output : %d\n", error);
goto err_timed_output_register;
}
#endif
pr_debug("[VIB] -- %s\n", __func__);
return error;
err_timed_output_register:
sysfs_remove_group(&motor_dev->kobj, &sec_motor_attr_group);
exit_sysfs:
sec_device_destroy(motor_dev->devt);
exit_sec_devices:
regulator_put(hap_data->regulator);
err_regulator_get:
pwm_free(hap_data->pwm);
err_pwm_request:
destroy_workqueue(hap_data->workqueue);
err_work_queue:
kfree(hap_data);
kfree(pdata);
g_hap_data = NULL;
return error;
}
