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; }