static void lp855x_led_class_unregister(struct lp855x *lp) { led_classdev_unregister(&lp->cdev); }
static int lm3556_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct lm3556_platform_data *pdata = client->dev.platform_data; int err = -1; if (pdata == NULL) { err = -ENODEV; dev_err(&client->dev, "platform data is NULL. exiting.\n"); goto error1; } if (!pdata->flags) { pr_err("%s: Device does not exist\n", __func__); err = ENODEV; goto error1; } if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { err = -ENODEV; dev_err(&client->dev, "client not i2c capable\n"); goto error1; } err = gpio_request(pdata->hw_enable, "camflash_en"); if (err < 0) { pr_err("%s: gpio_request(%d) failed\n", __func__, pdata->hw_enable); err = -ENODEV; goto error1; } err = gpio_direction_output(pdata->hw_enable, 1); if (err < 0) { gpio_free(pdata->hw_enable); pr_err("%s: gpio_direction_output(%d) failed\n", __func__, pdata->hw_enable); err = -ENODEV; goto error1; } torch_data = kzalloc(sizeof(struct lm3556_data), GFP_KERNEL); if (torch_data == NULL) { err = -ENOMEM; dev_err(&client->dev, "kzalloc failed\n"); gpio_free(pdata->hw_enable); goto error1; } pr_debug("%s\n", __func__); torch_data->client = client; torch_data->pdata = pdata; i2c_set_clientdata(client, torch_data); err = lm3556_init_registers(); if (err < 0) goto err_init_failed_release_gpio; evaluate_max_power(); torch_data->led_dev.name = LM3556_LED_DEV; torch_data->led_dev.brightness_set = NULL; err = led_classdev_register((struct device *) &client->dev, &torch_data->led_dev); if (err < 0) { err = -ENODEV; pr_err("%s: Register led class failed: %d\n", __func__, err); goto err_init_failed_release_gpio; } if (torch_data->pdata->flags & LM3556_TORCH) { pr_debug("%s: Creating Torch\n", __func__); err = device_create_file(torch_data->led_dev.dev, &dev_attr_flash_light); if (err < 0) { err = -ENODEV; pr_err("%s:File device creation failed: %d\n", __func__, err); goto err_reg_torch_file_failed; } pr_debug("%s: Creating Max_Torch_Power File\n", __func__); err = device_create_file(torch_data->led_dev.dev, &dev_attr_max_torch_power); if (err < 0) { pr_err("%s:File device creation failed: %d\n", __func__, err); err = -ENODEV; goto err_reg_max_torch_power_file_failed; } } if (torch_data->pdata->flags & LM3556_FLASH) { pr_debug("%s: Creating Flash\n", __func__); err = device_create_file(torch_data->led_dev.dev, &dev_attr_camera_strobe); if (err < 0) { err = -ENODEV; pr_err("%s:File device creation failed: %d\n", __func__, err); goto err_reg_flash_file_failed; } pr_debug("%s: Creating strobe error\n", __func__); err = device_create_file(torch_data->led_dev.dev, &dev_attr_strobe_err); if (err < 0) { err = -ENODEV; pr_err("%s:File device creation failed: %d\n", __func__, err); goto err_reg_strobe_error_file_failed; } pr_debug("%s: Creating Max_Strobe_Power File\n", __func__); err = device_create_file(torch_data->led_dev.dev, &dev_attr_max_strobe_power); if (err < 0) { pr_err("%s:File device creation failed: %d\n", __func__, err); err = -ENODEV; goto err_reg_max_strobe_power_file_failed; } } pr_debug("%s: Creating Registers File\n", __func__); err = device_create_file(torch_data->led_dev.dev, &dev_attr_registers); if (err < 0) { pr_err("%s:File device creation failed: %d\n", __func__, err); err = -ENODEV; goto err_reg_register_file_failed; } lm3556_probe_success = true; pr_debug("LM3556 Initialised"); return 0; err_reg_register_file_failed: if (torch_data->pdata->flags & LM3556_FLASH) device_remove_file(torch_data->led_dev.dev, &dev_attr_max_strobe_power); err_reg_max_strobe_power_file_failed: if (torch_data->pdata->flags & LM3556_FLASH) device_remove_file(torch_data->led_dev.dev, &dev_attr_strobe_err); err_reg_strobe_error_file_failed: if (torch_data->pdata->flags & LM3556_FLASH) device_remove_file(torch_data->led_dev.dev, &dev_attr_camera_strobe); err_reg_flash_file_failed: if (torch_data->pdata->flags & LM3556_TORCH) device_remove_file(torch_data->led_dev.dev, &dev_attr_max_torch_power); err_reg_max_torch_power_file_failed: if (torch_data->pdata->flags & LM3556_TORCH) device_remove_file(torch_data->led_dev.dev, &dev_attr_flash_light); err_reg_torch_file_failed: led_classdev_unregister(&torch_data->led_dev); err_init_failed_release_gpio: gpio_free(pdata->hw_enable); kfree(torch_data); error1: return err; }
static int __devinit lm3533_bl_probe(struct i2c_client *i2c_dev, const struct i2c_device_id *id) { struct lm3533_bl_platform_data *pdata; struct lm3533_device *dev; int err; dev_info(&i2c_dev->dev, "Starting backlight device probing..\n"); printk("YJChae lm3533_bl_probe : Starting backlight device probing..\n"); pdata = i2c_dev->dev.platform_data; dev = kzalloc(sizeof(struct lm3533_device), GFP_KERNEL); if (dev == NULL) { dev_err(&i2c_dev->dev,"fail alloc for lm3533_device\n"); return -ENOMEM; } #ifdef CONFIG_LM3533_LEDS_CLASS dev->client = i2c_dev; dev->hwen_gpio = pdata->hwen_gpio; dev->max_current= pdata->max_current; dev->max_brightness= LM3533_BL_MAX_BRIGHTNESS; dev->min_brightness= pdata->min_brightness; dev->default_brightness= LM3533_BL_DEFAULT_BRIGHTNESS; dev->cur_main_lcd_level= LM3533_BL_DEFAULT_BRIGHTNESS; dev->saved_main_lcd_level= LM3533_BL_DEFAULT_BRIGHTNESS; dev->bl_status = BL_OFF; err = led_classdev_register(&i2c_dev->dev, &lm3533_led_dev); if (err < 0) { dev_err(&i2c_dev->dev, "led_classdev_register failed\n"); goto err_led_classdev_register; } printk("Registering led class dev successfully.\n"); dev->led = &lm3533_led_dev; #endif i2c_set_clientdata(i2c_dev, dev); tegra_gpio_enable(dev->hwen_gpio); if (dev->hwen_gpio && gpio_request(dev->hwen_gpio, "lm3533 reset") != 0) { dev_err(&i2c_dev->dev, "gpio_request(%d) failed\n", dev->hwen_gpio); err = -ENODEV; goto err_gpio_request; } gpio_direction_output(dev->hwen_gpio, 1); dev->bl_status = BL_ON; mutex_init(&dev->bl_mutex); mutex_init(&dev->bl_mutex_saved); err = device_create_file(&i2c_dev->dev, &dev_attr_lm3533_bl_level); if (err < 0) { dev_err(&i2c_dev->dev, "device_create_file(level) failed\n"); goto err_device_create_file_1; } err = device_create_file(&i2c_dev->dev, &dev_attr_lm3533_bl_onoff); if (err < 0) { dev_err(&i2c_dev->dev, "device_create_file(onoff) failed\n"); goto err_device_create_file_2; } lm3533dev = dev; dev_info(&i2c_dev->dev, "lm3533 probed\n"); lm3533_driver_ready = 1; return 0; err_device_create_file_2: device_remove_file(&i2c_dev->dev, &dev_attr_lm3533_bl_level); err_device_create_file_1: gpio_free(dev->hwen_gpio); err_gpio_request: i2c_set_clientdata(i2c_dev, NULL); #ifdef CONFIG_LM3533_LEDS_CLASS led_classdev_unregister(dev->led); err_led_classdev_register: #endif kfree(dev); dev = NULL; return err; }
static int leds_sm5701_probe(struct platform_device *pdev) { struct SM5701_dev *iodev = dev_get_drvdata(pdev->dev.parent); struct SM5701_leds_data *chip; int err; printk("******* %s *******\n",__func__); chip = kzalloc(sizeof(struct SM5701_leds_data), GFP_KERNEL); if (!chip) return -ENOMEM; chip->dev = &pdev->dev; chip->iodev = iodev; platform_set_drvdata(pdev, chip); if (!(leds_sm5701_client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL))) { return -ENOMEM; } memset(leds_sm5701_client, 0, sizeof(struct i2c_client)); leds_sm5701_client = chip->iodev->i2c; mutex_init(&chip->lock); /* flash */ INIT_WORK(&chip->work_flash, sm5701_deferred_flash_brightness_set); chip->cdev_flash.name = "flash"; chip->cdev_flash.max_brightness = 32-1;//0x1f chip->cdev_flash.brightness_set = sm5701_flash_brightness_set; chip->cdev_flash.default_trigger = "flash"; err = led_classdev_register((struct device *) chip->dev, &chip->cdev_flash); if (err < 0) { dev_err(chip->dev, "failed to register flash\n"); goto err_create_flash_file; } err = device_create_file(chip->cdev_flash.dev, &dev_attr_flash); if (err < 0) { dev_err(chip->dev, "failed to create flash file\n"); goto err_create_flash_pin_file; } /* movie */ INIT_WORK(&chip->work_movie, sm5701_deferred_movie_brightness_set); chip->cdev_movie.name = "movie"; chip->cdev_movie.max_brightness = 32-1;//0x1f chip->cdev_movie.brightness_set = sm5701_movie_brightness_set; chip->cdev_movie.default_trigger = "movie"; err = led_classdev_register((struct device *) chip->dev, &chip->cdev_movie); if (err < 0) { dev_err(chip->dev, "failed to register movie\n"); goto err_create_movie_file; } err = device_create_file(chip->cdev_movie.dev, &dev_attr_movie); if (err < 0) { dev_err(chip->dev, "failed to create movie file\n"); goto err_create_movie_pin_file; } err = sm5701_chip_init(chip); if (err < 0) goto err_out; //sm5701_dump_register(); dev_info(chip->dev, "LEDs_SM5701 Probe Done\n"); return 0; err_create_movie_file: device_remove_file(chip->cdev_movie.dev, &dev_attr_movie); err_create_movie_pin_file: led_classdev_unregister(&chip->cdev_movie); err_create_flash_file: device_remove_file(chip->cdev_flash.dev, &dev_attr_flash); err_create_flash_pin_file: led_classdev_unregister(&chip->cdev_flash); err_out: return err; }
static int __devinit pm8xxx_led_probe(struct platform_device *pdev) { const struct pm8xxx_led_platform_data *pdata = pdev->dev.platform_data; struct pm8xxx_led_configure *curr_led; struct pm8xxx_led_data *led, *led_dat; int i, ret = -ENOMEM; if (pdata == NULL) { LED_ERR("platform data not supplied\n"); return -EINVAL; } led = kcalloc(pdata->num_leds + 1, sizeof(*led), GFP_KERNEL); if (led == NULL) { LED_ERR("failed to alloc memory\n"); return -ENOMEM; } wake_lock_init(&pmic_led_wake_lock, WAKE_LOCK_SUSPEND, "pmic_led"); g_led_work_queue = create_workqueue("pm8xxx-led"); if (g_led_work_queue == NULL) { LED_ERR("failed to create workqueue\n"); goto err_create_work_queue; } for (i = 0; i < pdata->num_leds; i++) { curr_led = &pdata->leds[i]; led_dat = &led[i]; led_dat->cdev.name = curr_led->name; led_dat->id = curr_led->flags; led_dat->bank = curr_led->flags; led_dat->function_flags = curr_led->function_flags; led_dat->start_index = curr_led->start_index; led_dat->duty_time_ms = curr_led->duty_time_ms; led_dat->period_us = curr_led->period_us; led_dat->duites_size = curr_led->duites_size; led_dat->lut_flag = curr_led->lut_flag; led_dat->out_current = curr_led->out_current; led_dat->duties = &(curr_led->duties[0]); led_dat->led_sync = curr_led->led_sync; led_dat->pwm_led = pwm_request(led_dat->bank, led_dat->cdev.name); if( curr_led->pwm_coefficient > 0 ) led_dat->pwm_coefficient = curr_led->pwm_coefficient; else led_dat->pwm_coefficient = 100; switch (led_dat->id) { case PM8XXX_ID_GPIO24: case PM8XXX_ID_GPIO25: case PM8XXX_ID_GPIO26: led_dat->cdev.brightness_set = pm8xxx_led_gpio_set; if (curr_led->gpio_status_switch != NULL) led_dat->gpio_status_switch = curr_led->gpio_status_switch; break; case PM8XXX_ID_LED_0: case PM8XXX_ID_LED_1: case PM8XXX_ID_LED_2: led_dat->cdev.brightness_set = pm8xxx_led_current_set; if (led_dat->function_flags & LED_PWM_FUNCTION) { led_dat->reg = pm8xxxx_led_pwm_mode(led_dat->id); INIT_DELAYED_WORK(&led[i].fade_delayed_work, led_fade_do_work); } else led_dat->reg = PM8XXX_LED_MODE_MANUAL; break; case PM8XXX_ID_LED_KB_LIGHT: break; } led_dat->cdev.brightness = LED_OFF; led_dat->dev = &pdev->dev; ret = led_classdev_register(&pdev->dev, &led_dat->cdev); if (ret) { LED_ERR("unable to register led %d,ret=%d\n", led_dat->id, ret); goto err_register_led_cdev; } // blink buttons if (led_dat->id == PM8XXX_ID_LED_0) { // storing buttons light dev for blinking led_cdev_buttons = &led_dat->cdev; ret = device_create_file(led_dat->cdev.dev, &dev_attr_bln); if (ret < 0) { LED_ERR("%s: Failed to create %d attr currents\n", __func__, i); goto err_register_attr_currents; } } // blink buttons end if (led_dat->id >= PM8XXX_ID_LED_2 && led_dat->id <= PM8XXX_ID_LED_0) { ret = device_create_file(led_dat->cdev.dev, &dev_attr_currents); if (ret < 0) { LED_ERR("%s: Failed to create %d attr currents\n", __func__, i); goto err_register_attr_currents; } } if (led_dat->id <= PM8XXX_ID_GPIO26) { ret = device_create_file(led_dat->cdev.dev, &dev_attr_pwm_coefficient); if (ret < 0) { LED_ERR("%s: Failed to create %d attr pwm_coefficient\n", __func__, i); goto err_register_attr_pwm_coefficient; } } if (led_dat->function_flags & LED_BLINK_FUNCTION) { INIT_DELAYED_WORK(&led[i].blink_delayed_work, led_blink_do_work); ret = device_create_file(led_dat->cdev.dev, &dev_attr_blink); if (ret < 0) { LED_ERR("%s: Failed to create %d attr blink\n", __func__, i); goto err_register_attr_blink; } ret = device_create_file(led_dat->cdev.dev, &dev_attr_off_timer); if (ret < 0) { LED_ERR("%s: Failed to create %d attr off timer\n", __func__, i); goto err_register_attr_off_timer; } alarm_init(&led[i].led_alarm, ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP, led_alarm_handler); INIT_WORK(&led[i].led_work, led_work_func); } if (!strcmp(led_dat->cdev.name, "button-backlight")) { for_key_led_data = led_dat; } if (!strcmp(led_dat->cdev.name, "green-back")) { LED_INFO("%s: matt green-back, 000 probe, led_dat = %x\n", __func__, (unsigned int)led_dat); green_back_led_data = led_dat; } if (!strcmp(led_dat->cdev.name, "amber-back")) { LED_INFO("%s: matt amber-back\n", __func__); amber_back_led_data = led_dat; } } pm8xxx_leds = led; platform_set_drvdata(pdev, led); return 0; err_register_attr_off_timer: if (i > 0) { for (i = i - 1; i >= 0; i--) { if (led[i].function_flags & LED_BLINK_FUNCTION) device_remove_file(led[i].cdev.dev, &dev_attr_off_timer); } } i = pdata->num_leds; err_register_attr_blink: if (i > 0) { for (i = i - 1; i >= 0; i--) { if (led[i].function_flags & LED_BLINK_FUNCTION) device_remove_file(led[i].cdev.dev, &dev_attr_blink); } } i = pdata->num_leds; err_register_attr_pwm_coefficient: if (i > 0) { for (i = i - 1; i >= 0; i--) { if (led[i].function_flags <= PM8XXX_ID_GPIO26) device_remove_file(led[i].cdev.dev, &dev_attr_pwm_coefficient); } } i = pdata->num_leds; err_register_attr_currents: if (i > 0) { for (i = i - 1; i >= 0; i--) { if (led[i].function_flags >= PM8XXX_ID_LED_2 && led[i].function_flags <= PM8XXX_ID_LED_0) device_remove_file(led[i].cdev.dev, &dev_attr_currents); } } i = pdata->num_leds; err_register_led_cdev: if (i > 0) { for (i = i - 1; i >= 0; i--) { pwm_free(led[i].pwm_led); led_classdev_unregister(&led[i].cdev); } } destroy_workqueue(g_led_work_queue); err_create_work_queue: kfree(led); wake_lock_destroy(&pmic_led_wake_lock); return ret; }
static int lm3630a_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct lm3630a_platform_data *pdata = dev_get_platdata(&client->dev); struct lm3630a_chip *pchip; struct device_node *np = client->dev.of_node; int rval; if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { dev_err(&client->dev, "fail : i2c functionality check\n"); return -EOPNOTSUPP; } pchip = devm_kzalloc(&client->dev, sizeof(struct lm3630a_chip), GFP_KERNEL); if (!pchip) return -ENOMEM; pchip->dev = &client->dev; pchip->regmap = devm_regmap_init_i2c(client, &lm3630a_regmap); if (IS_ERR(pchip->regmap)) { rval = PTR_ERR(pchip->regmap); dev_err(&client->dev, "fail : allocate reg. map: %d\n", rval); return rval; } i2c_set_clientdata(client, pchip); if (pdata == NULL) { pdata = devm_kzalloc(pchip->dev, sizeof(struct lm3630a_platform_data), GFP_KERNEL); if (pdata == NULL) return -ENOMEM; pchip->pdata = pdata; if (lm3630a_parse_dt(np, pchip)) return -EINVAL; } else pchip->pdata = pdata; /* chip initialize */ rval = lm3630a_chip_init(pchip); if (rval < 0) { dev_err(&client->dev, "fail : init chip\n"); return rval; } /* backlight register */ if (is_fb_backlight) { rval = lm3630a_backlight_register(pchip); if (rval < 0) { dev_err(&client->dev, "fail : backlight register.\n"); goto err1; } } else { pchip->ledcdev = lm3630a_led_cdev; INIT_WORK(&pchip->ledwork, lm3630a_led_set_func); rval = led_classdev_register(pchip->dev, &pchip->ledcdev); if (rval) { dev_err(pchip->dev, "unable to register %s,rc=%d\n", lm3630a_led_cdev.name, rval); return rval; } pchip->ledwq = create_singlethread_workqueue("lm3630a-led-wq"); if (!pchip->ledwq) { dev_err(pchip->dev, "fail to create led thread\n"); rval = -ENOMEM; goto err1; } } /* pwm */ if (pdata->pwm_ctrl != LM3630A_PWM_DISABLE) { pchip->pwmd = pwm_request(pdata->pwm_gpio, "lm3630a-pwm"); if (IS_ERR(pchip->pwmd)) { dev_err(&client->dev, "fail : get pwm device\n"); rval = PTR_ERR(pchip->pwmd); goto err1; } } /* interrupt enable : irq 0 is not allowed */ if (pchip->irq) { rval = lm3630a_intr_config(pchip); if (rval < 0) goto err2; } dev_info(&client->dev, "LM3630A backlight register OK.\n"); return 0; err2: if (!IS_ERR_OR_NULL(pchip->pwmd)) pwm_free(pchip->pwmd); if (pchip->irq) free_irq(pchip->irq, pchip); if (pchip->irqthread) { flush_workqueue(pchip->irqthread); destroy_workqueue(pchip->irqthread); } err1: if (is_fb_backlight) { if (!IS_ERR_OR_NULL(pchip->bleda)) backlight_device_unregister(pchip->bleda); if (!IS_ERR_OR_NULL(pchip->bledb)) backlight_device_unregister(pchip->bledb); } else led_classdev_unregister(&pchip->ledcdev); return rval; }
static int pm8058_led_probe(struct platform_device *pdev) { struct pm8058_led_platform_data *pdata; struct pm8058_led_data *ldata; int i, ret; ret = -ENOMEM; pdata = pdev->dev.platform_data; if (pdata == NULL) { pr_err("%s: platform data is NULL\n", __func__); return -ENODEV; } ldata = kzalloc(sizeof(struct pm8058_led_data) * pdata->num_leds, GFP_KERNEL); if (!ldata && pdata->num_leds) { ret = -ENOMEM; pr_err("%s: failed on allocate ldata\n", __func__); goto err_exit; } dev_set_drvdata(&pdev->dev, ldata); wake_lock_init(&pmic_led_wake_lock, WAKE_LOCK_SUSPEND, "pmic_led"); g_led_work_queue = create_workqueue("led"); if (!g_led_work_queue) goto err_create_work_queue; for (i = 0; i < 64; i++) duties[i] = pdata->duties[i]; for (i = 0; i < pdata->num_leds; i++) { ldata[i].led_config = pdata->led_config + i; ldata[i].ldev.name = pdata->led_config[i].name; ldata[i].bank = pdata->led_config[i].bank; ldata[i].flags = pdata->led_config[i].flags; ldata[i].pwm_size = pdata->led_config[i].pwm_size; ldata[i].clk = pdata->led_config[i].clk; ldata[i].pre_div = pdata->led_config[i].pre_div; ldata[i].pre_div_exp = pdata->led_config[i].pre_div_exp; ldata[i].pwm_value = pdata->led_config[i].pwm_value; ldata[i].period_us = pdata->led_config[i].period_us; ldata[i].start_index = pdata->led_config[i].start_index; ldata[i].duites_size = pdata->led_config[i].duites_size; ldata[i].duty_time_ms = pdata->led_config[i].duty_time_ms; ldata[i].lut_flag = pdata->led_config[i].lut_flag; ldata[i].out_current = pdata->led_config[i].out_current; switch (pdata->led_config[i].type) { case PM8058_LED_CURRENT: if (ldata[i].flags & PM8058_LED_BLINK_EN) INIT_DELAYED_WORK(&ldata[i].led_delayed_work, led_blink_do_work); else INIT_DELAYED_WORK(&ldata[i].led_delayed_work, pwm_lut_delayed_fade_out); ldata[i].pwm_led = pwm_request(ldata[i].bank, ldata[i].ldev.name); ldata[i].ldev.brightness_set = pm8058_drvx_led_brightness_set; break; case PM8058_LED_RGB: INIT_DELAYED_WORK(&ldata[i].led_delayed_work, led_blink_do_work); case PM8058_LED_PWM: ldata[i].pwm_led = pwm_request(ldata[i].bank, ldata[i].ldev.name); ldata[i].ldev.brightness_set = pm8058_pwm_led_brightness_set; break; case PM8058_LED_DRVX: if (ldata[i].flags & PM8058_LED_BLINK_EN) INIT_DELAYED_WORK(&ldata[i].led_delayed_work, led_blink_do_work); else INIT_DELAYED_WORK(&ldata[i].led_delayed_work, pwm_lut_delayed_fade_out); ldata[i].pwm_led = pwm_request(ldata[i].bank, ldata[i].ldev.name); ldata[i].ldev.brightness_set = pm8058_drvx_led_brightness_set; break; } ret = led_classdev_register(&pdev->dev, &ldata[i].ldev); if (ret < 0) { pr_err("%s: failed on led_classdev_register [%s]\n", __func__, ldata[i].ldev.name); goto err_register_led_cdev; } } for (i = 0; i < pdata->num_leds; i++) { if (pdata->led_config[i].type == PM8058_LED_RGB || ldata[i].flags & PM8058_LED_BLINK_EN) { ret = device_create_file(ldata[i].ldev.dev, &dev_attr_blink); if (ret < 0) { pr_err("%s: Failed to create attr blink" " [%d]\n", __func__, i); goto err_register_attr_blink; } } } for (i = 0; i < pdata->num_leds; i++) { if (pdata->led_config[i].type == PM8058_LED_RGB || ldata[i].flags & PM8058_LED_BLINK_EN) { ret = device_create_file(ldata[i].ldev.dev, &dev_attr_off_timer); if (ret < 0) { pr_err("%s: Failed to create attr off timer" " [%d]\n", __func__, i); goto err_register_attr_off_timer; } INIT_WORK(&ldata[i].led_work, led_work_func); alarm_init(&ldata[i].led_alarm, ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP, led_alarm_handler); } } for (i = 0; i < pdata->num_leds; i++) { if (ldata[i].bank < 3) continue; ret = device_create_file(ldata[i].ldev.dev, &dev_attr_currents); if (ret < 0) { pr_err("%s: Failed to create attr blink [%d]\n", __func__, i); goto err_register_attr_currents; } } return 0; err_register_attr_currents: for (i--; i >= 0; i--) { if (ldata[i].bank < 3) continue; device_remove_file(ldata[i].ldev.dev, &dev_attr_currents); } i = pdata->num_leds; err_register_attr_off_timer: for (i--; i >= 0; i--) { if (pdata->led_config[i].type == PM8058_LED_RGB || ldata[i].flags & PM8058_LED_BLINK_EN) { device_remove_file(ldata[i].ldev.dev, &dev_attr_off_timer); } } i = pdata->num_leds; err_register_attr_blink: for (i--; i >= 0; i--) { if (pdata->led_config[i].type == PM8058_LED_RGB || ldata[i].flags & PM8058_LED_BLINK_EN) { device_remove_file(ldata[i].ldev.dev, &dev_attr_blink); } } i = pdata->num_leds; err_register_led_cdev: for (i--; i >= 0; i--) { switch (pdata->led_config[i].type) { case PM8058_LED_RGB: case PM8058_LED_PWM: case PM8058_LED_DRVX: pwm_free(ldata[i].pwm_led); break; } led_classdev_unregister(&ldata[i].ldev); } destroy_workqueue(g_led_work_queue); err_create_work_queue: kfree(ldata); err_exit: wake_lock_destroy(&pmic_led_wake_lock); return ret; }
static void devm_led_classdev_release(struct device *dev, void *res) { led_classdev_unregister(*(struct led_classdev **)res); }
static void fan5646_unregister_leds(struct device *dev) { struct fan5646_data *pdata = dev_get_drvdata(dev); led_classdev_unregister(&pdata->led); led_classdev_unregister(&pdata->rgb); }
static int max77693_led_probe(struct platform_device *pdev) { int ret = 0; int i; struct max77693_dev *max77693 = dev_get_drvdata(pdev->dev.parent); struct max77693_platform_data *max77693_pdata = dev_get_platdata(max77693->dev); struct max77693_led_platform_data *pdata = max77693_pdata->led_data; struct max77693_led_data *led_data; struct max77693_led *data; struct max77693_led_data **led_datas; if (pdata == NULL) { pr_err("[LED] no platform data for this led is found\n"); return -EFAULT; } led_datas = kzalloc(sizeof(struct max77693_led_data *) * MAX77693_LED_MAX, GFP_KERNEL); if (unlikely(!led_datas)) { pr_err("[LED] memory allocation error %s", __func__); return -ENOMEM; } platform_set_drvdata(pdev, led_datas); pr_debug("[LED] %s\n", __func__); for (i = 0; i != pdata->num_leds; ++i) { data = &(pdata->leds[i]); led_data = kzalloc(sizeof(struct max77693_led_data), GFP_KERNEL); led_datas[i] = led_data; if (unlikely(!led_data)) { pr_err("[LED] memory allocation error %s\n", __func__); ret = -ENOMEM; continue; } led_data->max77693 = max77693; led_data->i2c = max77693->i2c; led_data->data = data; led_data->led.name = data->name; led_data->led.brightness_set = max77693_led_set; led_data->led.brightness = LED_OFF; led_data->brightness = data->brightness; led_data->led.flags = LED_CORE_SUSPENDRESUME; led_data->led.max_brightness = data->id < 2 ? MAX_FLASH_DRV_LEVEL : MAX_TORCH_DRV_LEVEL; mutex_init(&led_data->lock); spin_lock_init(&led_data->value_lock); INIT_WORK(&led_data->work, max77693_led_work); ret = led_classdev_register(&pdev->dev, &led_data->led); if (unlikely(ret)) { pr_err("unable to register LED\n"); kfree(led_data); ret = -EFAULT; continue; } ret = max77693_led_setup(led_data); if (unlikely(ret)) { pr_err("unable to register LED\n"); led_classdev_unregister(&led_data->led); kfree(led_data); ret = -EFAULT; } } /* print_all_reg_value(max77693->i2c); */ if (pdata->hw_init) pdata->hw_init(); /* important */ max77693_led_torch_en = pdata->torch_en; max77693_led_create_node(pdata); return ret; }
static int wndr3700_usb_led_remove(struct platform_device *pdev) { led_classdev_unregister(&wndr3700_usb_led); return 0; }
static int __devinit max77665_led_probe(struct platform_device *pdev) { struct max77665_dev *iodev = dev_get_drvdata(pdev->dev.parent); struct max77665_platform_data *pdata = dev_get_platdata(iodev->dev); struct max77665_led *led; int ret = 0; if (pdata == NULL) { dev_err(&pdev->dev, "no platform data\n"); return -ENODEV; } led = kzalloc(sizeof(*led), GFP_KERNEL); if (led == NULL) { ret = -ENOMEM; goto err_mem; } led->id = pdev->id; led->cdev.name = "flash_led"; led->cdev.brightness_set = max77665_led_brightness_set; led->cdev.flags |= LED_CORE_SUSPENDRESUME; led->cdev.brightness = 0; led->iodev = iodev; /* initialize mode and brightness according to platform_data */ if (pdata->led_pdata) { u8 mode = 0, brightness = 0; mode = pdata->led_pdata->mode[led->id]; brightness = pdata->led_pdata->brightness[led->id]; max77665_led_set_mode(led, pdata->led_pdata->mode[led->id]); if (brightness > led->cdev.max_brightness) brightness = led->cdev.max_brightness; max77665_led_set_current(led, brightness); led->cdev.brightness = brightness; } else { max77665_led_set_mode(led, MAX77665_NONE); max77665_led_set_current(led, 0); } max77665_flash_setup(led); mutex_init(&led->mutex); platform_set_drvdata(pdev, led); ret = led_classdev_register(&pdev->dev, &led->cdev); if (ret < 0) goto err_led; ret = device_create_file(led->cdev.dev, &dev_attr_mode); if (ret != 0) { dev_err(&pdev->dev, "failed to create file: %d\n", ret); goto err_file; } g_data = led; dev_info(&pdev->dev,"--\n"); return 0; err_file: led_classdev_unregister(&led->cdev); err_led: kfree(led); err_mem: return ret; }
static int __devinit pm8xxx_led_probe(struct platform_device *pdev) { const struct pm8xxx_led_platform_data *pdata = pdev->dev.platform_data; struct pm8xxx_led_configure *curr_led; struct pm8xxx_led_data *led, *led_dat; int i, ret = -ENOMEM; if (pdata == NULL) { LED_ERR("platform data not supplied\n"); return -EINVAL; } /* Let the last member of the list be zero to * mark the end of the list. */ led = kcalloc(pdata->num_leds + 1, sizeof(*led), GFP_KERNEL); if (led == NULL) { LED_ERR("failed to alloc memory\n"); return -ENOMEM; } g_led_work_queue = create_workqueue("pm8xxx-led"); if (g_led_work_queue == NULL) { LED_ERR("failed to create workqueue\n"); goto err_create_work_queue; } for (i = 0; i < pdata->num_leds; i++) { curr_led = &pdata->leds[i]; led_dat = &led[i]; led_dat->cdev.name = curr_led->name; led_dat->id = curr_led->flags; led_dat->bank = curr_led->flags; led_dat->function_flags = curr_led->function_flags; led_dat->start_index = curr_led->start_index; led_dat->duty_time_ms = curr_led->duty_time_ms; led_dat->period_us = curr_led->period_us; led_dat->duites_size = curr_led->duites_size; led_dat->lut_flag = curr_led->lut_flag; led_dat->out_current = curr_led->out_current; led_dat->duties = &(curr_led->duties[0]); led_dat->pwm_led = pwm_request(led_dat->bank, led_dat->cdev.name); switch (led_dat->id) { case PM8XXX_ID_GPIO24: case PM8XXX_ID_GPIO25: case PM8XXX_ID_GPIO26: led_dat->cdev.brightness_set = pm8xxx_led_gpio_set; if (curr_led->gpio_status_switch != NULL) led_dat->gpio_status_switch = curr_led->gpio_status_switch; break; case PM8XXX_ID_LED_0: case PM8XXX_ID_LED_1: case PM8XXX_ID_LED_2: led_dat->cdev.brightness_set = pm8xxx_led_current_set; if (led_dat->function_flags & LED_PWM_FUNCTION) { led_dat->reg = pm8xxxx_led_pwm_mode(led_dat->id); INIT_DELAYED_WORK(&led[i].fade_delayed_work, led_fade_do_work); } else led_dat->reg = PM8XXX_LED_MODE_MANUAL; break; case PM8XXX_ID_LED_KB_LIGHT: break; } led_dat->cdev.brightness = LED_OFF; led_dat->dev = &pdev->dev; ret = led_classdev_register(&pdev->dev, &led_dat->cdev); if (ret) { LED_ERR("unable to register led %d,ret=%d\n", led_dat->id, ret); goto err_register_led_cdev; } if (led_dat->id >= PM8XXX_ID_LED_2 && led_dat->id <= PM8XXX_ID_LED_0) { ret = device_create_file(led_dat->cdev.dev, &dev_attr_currents); if (ret < 0) { LED_ERR("%s: Failed to create %d attr currents\n", __func__, i); goto err_register_attr_currents; } } if (led_dat->function_flags & LED_BLINK_FUNCTION) { INIT_DELAYED_WORK(&led[i].blink_delayed_work, led_blink_do_work); ret = device_create_file(led_dat->cdev.dev, &dev_attr_blink); if (ret < 0) { LED_ERR("%s: Failed to create %d attr blink\n", __func__, i); goto err_register_attr_blink; } ret = device_create_file(led_dat->cdev.dev, &dev_attr_off_timer); if (ret < 0) { LED_ERR("%s: Failed to create %d attr off timer\n", __func__, i); goto err_register_attr_off_timer; } alarm_init(&led[i].led_alarm, ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP, led_alarm_handler); INIT_WORK(&led[i].led_work, led_work_func); /*Off blink after alarm*/ } if(led_dat->id == PM8XXX_ID_LED_0) { for_key_led_data = led_dat; } } pm8xxx_leds = led; platform_set_drvdata(pdev, led); return 0; err_register_attr_off_timer: if (i > 0) { for (i = i - 1; i >= 0; i--) { if (led[i].function_flags & LED_BLINK_FUNCTION) device_remove_file(led[i].cdev.dev, &dev_attr_off_timer); } } i = pdata->num_leds; err_register_attr_blink: if (i > 0) { for (i = i - 1; i >= 0; i--) { if (led[i].function_flags & LED_BLINK_FUNCTION) device_remove_file(led[i].cdev.dev, &dev_attr_blink); } } i = pdata->num_leds; err_register_attr_currents: if (i > 0) { for (i = i - 1; i >= 0; i--) { if (led[i].function_flags >= PM8XXX_ID_LED_2 && led[i].function_flags <= PM8XXX_ID_LED_0) device_remove_file(led[i].cdev.dev, &dev_attr_currents); } } i = pdata->num_leds; err_register_led_cdev: if (i > 0) { for (i = i - 1; i >= 0; i--) { pwm_free(led[i].pwm_led); led_classdev_unregister(&led[i].cdev); } } destroy_workqueue(g_led_work_queue); err_create_work_queue: kfree(led); return ret; }
static int lm3639_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret; struct lm3639_chip_data *pchip; struct lm3639_platform_data *pdata = dev_get_platdata(&client->dev); struct backlight_properties props; if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { dev_err(&client->dev, "i2c functionality check fail.\n"); return -EOPNOTSUPP; } if (pdata == NULL) { dev_err(&client->dev, "Needs Platform Data.\n"); return -ENODATA; } pchip = devm_kzalloc(&client->dev, sizeof(struct lm3639_chip_data), GFP_KERNEL); if (!pchip) return -ENOMEM; pchip->pdata = pdata; pchip->dev = &client->dev; pchip->regmap = devm_regmap_init_i2c(client, &lm3639_regmap); if (IS_ERR(pchip->regmap)) { ret = PTR_ERR(pchip->regmap); dev_err(&client->dev, "fail : allocate register map: %d\n", ret); return ret; } i2c_set_clientdata(client, pchip); /* chip initialize */ ret = lm3639_chip_init(pchip); if (ret < 0) { dev_err(&client->dev, "fail : chip init\n"); goto err_out; } /* backlight */ props.type = BACKLIGHT_RAW; props.brightness = pdata->init_brt_led; props.max_brightness = pdata->max_brt_led; pchip->bled = devm_backlight_device_register(pchip->dev, "lm3639_bled", pchip->dev, pchip, &lm3639_bled_ops, &props); if (IS_ERR(pchip->bled)) { dev_err(&client->dev, "fail : backlight register\n"); ret = PTR_ERR(pchip->bled); goto err_out; } ret = device_create_file(&(pchip->bled->dev), &dev_attr_bled_mode); if (ret < 0) { dev_err(&client->dev, "failed : add sysfs entries\n"); goto err_out; } /* flash */ pchip->cdev_flash.name = "lm3639_flash"; pchip->cdev_flash.max_brightness = 16; pchip->cdev_flash.brightness_set = lm3639_flash_brightness_set; ret = led_classdev_register((struct device *) &client->dev, &pchip->cdev_flash); if (ret < 0) { dev_err(&client->dev, "fail : flash register\n"); goto err_flash; } /* torch */ pchip->cdev_torch.name = "lm3639_torch"; pchip->cdev_torch.max_brightness = 8; pchip->cdev_torch.brightness_set = lm3639_torch_brightness_set; ret = led_classdev_register((struct device *) &client->dev, &pchip->cdev_torch); if (ret < 0) { dev_err(&client->dev, "fail : torch register\n"); goto err_torch; } return 0; err_torch: led_classdev_unregister(&pchip->cdev_flash); err_flash: device_remove_file(&(pchip->bled->dev), &dev_attr_bled_mode); err_out: return ret; }
static void __exit dell_led_exit(void) { led_classdev_unregister(&dell_led); led_off(); }
static void __exit mb628_led_exit(void) { led_classdev_unregister(&mb628_led); }
static void delete_led(struct led_info_data *led) { led_classdev_unregister(&led->cdev); //cancel_work_sync(&led->work); }
static int __devinit tricolor_led_probe(struct platform_device *pdev) { const struct led_platform_data *pdata = pdev->dev.platform_data; struct msm_rpc_client *rpc_client; struct led_info *curr_led; struct tricolor_led_data *led, *tmp_led; int rc, i, j; if (!pdata) { dev_err(&pdev->dev, "platform data not supplied\n"); return -EINVAL; } /* initialize rpc client */ rpc_client = msm_rpc_register_client("led", LED_RPC_PROG, LED_RPC_VER, 0, led_cb_func); rc = IS_ERR(rpc_client); if (rc) { dev_err(&pdev->dev, "failed to initialize rpc_client\n"); return -EINVAL; } /* subscribe */ rc = msm_rpc_client_req(rpc_client, LED_SUBSCRIBE_PROC, led_rpc_register_subs_arg, NULL, led_rpc_res, NULL, -1); if (rc) { pr_err("%s: RPC client request failed for subscribe services\n", __func__); goto fail_mem_alloc; } led = devm_kzalloc(&pdev->dev, pdata->num_leds * sizeof(*led), GFP_KERNEL); if (!led) { dev_err(&pdev->dev, "failed to alloc memory\n"); rc = -ENOMEM; goto fail_mem_alloc; } for (i = 0; i < pdata->num_leds; i++) { curr_led = &pdata->leds[i]; tmp_led = &led[i]; tmp_led->cdev.name = curr_led->name; tmp_led->cdev.default_trigger = curr_led->default_trigger; tmp_led->cdev.brightness_set = tricolor_led_set; tmp_led->cdev.brightness_get = tricolor_led_get; tmp_led->cdev.brightness = LED_OFF; tmp_led->cdev.max_brightness = LED_FULL; tmp_led->color = curr_led->flags; tmp_led->rpc_client = rpc_client; tmp_led->blink_status = false; mutex_init(&tmp_led->lock); rc = led_classdev_register(&pdev->dev, &tmp_led->cdev); if (rc) { dev_err(&pdev->dev, "failed to register led %s(%d)\n", tmp_led->cdev.name, rc); goto fail_led_reg; } /* Add blink attributes */ rc = device_create_file(tmp_led->cdev.dev, &dev_attr_blink); if (rc) { dev_err(&pdev->dev, "failed to create blink attr\n"); goto fail_blink_attr; } dev_set_drvdata(tmp_led->cdev.dev, tmp_led); } platform_set_drvdata(pdev, led); return 0; fail_blink_attr: j = i; while (j) device_remove_file(led[--j].cdev.dev, &dev_attr_blink); i++; fail_led_reg: while (i) { led_classdev_unregister(&led[--i].cdev); mutex_destroy(&led[i].lock); } fail_mem_alloc: msm_rpc_unregister_client(rpc_client); return rc; }
static void delete_netxbig_led(struct netxbig_led_data *led_dat) { if (led_dat->mode_val[NETXBIG_LED_SATA] != NETXBIG_LED_INVALID_MODE) device_remove_file(led_dat->cdev.dev, &dev_attr_sata); led_classdev_unregister(&led_dat->cdev); }
static int g19_probe(struct hid_device *hdev, const struct hid_device_id *id) { unsigned long irq_flags; int error; struct g19_data *data; int i; int led_num; struct usb_interface *intf; struct usb_device *usbdev; struct list_head *feature_report_list = &hdev->report_enum[HID_FEATURE_REPORT].report_list; struct hid_report *report; char *led_name; dev_dbg(&hdev->dev, "Logitech G19 HID hardware probe..."); /* Get the usb device to send the start report on */ intf = to_usb_interface(hdev->dev.parent); usbdev = interface_to_usbdev(intf); /* * Let's allocate the g19 data structure, set some reasonable * defaults, and associate it with the device */ data = kzalloc(sizeof(struct g19_data), GFP_KERNEL); if (data == NULL) { dev_err(&hdev->dev, "can't allocate space for Logitech G19 device attributes\n"); error = -ENOMEM; goto err_no_cleanup; } spin_lock_init(&data->lock); init_completion(&data->ready); data->hdev = hdev; data->ep1_urb = usb_alloc_urb(0, GFP_KERNEL); if (data->ep1_urb == NULL) { dev_err(&hdev->dev, G19_NAME ": ERROR: can't alloc ep1 urb stuff\n"); error = -ENOMEM; goto err_cleanup_data; } hid_set_drvdata(hdev, data); dbg_hid("Preparing to parse " G19_NAME " hid reports\n"); /* Parse the device reports and start it up */ error = hid_parse(hdev); if (error) { dev_err(&hdev->dev, G19_NAME " device report parse failed\n"); error = -EINVAL; goto err_cleanup_ep1_urb; } error = hid_hw_start(hdev, HID_CONNECT_DEFAULT | HID_CONNECT_HIDINPUT_FORCE); if (error) { dev_err(&hdev->dev, G19_NAME " hardware start failed\n"); error = -EINVAL; goto err_cleanup_ep1_urb; } dbg_hid(G19_NAME " claimed: %d\n", hdev->claimed); error = hdev->ll_driver->open(hdev); if (error) { dev_err(&hdev->dev, G19_NAME " failed to open input interrupt pipe for key and joystick events\n"); error = -EINVAL; goto err_cleanup_ep1_urb; } /* Set up the input device for the key I/O */ data->input_dev = input_allocate_device(); if (data->input_dev == NULL) { dev_err(&hdev->dev, G19_NAME " error initializing the input device"); error = -ENOMEM; goto err_cleanup_ep1_urb; } input_set_drvdata(data->input_dev, hdev); data->input_dev->name = G19_NAME; data->input_dev->phys = hdev->phys; data->input_dev->uniq = hdev->uniq; data->input_dev->id.bustype = hdev->bus; data->input_dev->id.vendor = hdev->vendor; data->input_dev->id.product = hdev->product; data->input_dev->id.version = hdev->version; data->input_dev->dev.parent = hdev->dev.parent; data->input_dev->keycode = data->keycode; data->input_dev->keycodemax = G19_KEYMAP_SIZE; data->input_dev->keycodesize = sizeof(int); data->input_dev->setkeycode = g19_input_setkeycode; data->input_dev->getkeycode = g19_input_getkeycode; input_set_capability(data->input_dev, EV_KEY, KEY_UNKNOWN); data->input_dev->evbit[0] |= BIT_MASK(EV_REP); g19_initialize_keymap(data); error = input_register_device(data->input_dev); if (error) { dev_err(&hdev->dev, G19_NAME " error registering the input device"); error = -EINVAL; goto err_cleanup_input_dev; } if (list_empty(feature_report_list)) { dev_err(&hdev->dev, "no feature report found\n"); error = -ENODEV; goto err_cleanup_input_dev_reg; } dbg_hid(G19_NAME " feature report found\n"); list_for_each_entry(report, feature_report_list, list) { switch (report->id) { case 0x04: data->feature_report_4 = report; break; case 0x05: data->led_report = report; break; case 0x06: data->start_input_report = report; break; case 0x07: data->backlight_report = report; break; default: break; } dbg_hid(G19_NAME " Feature report: id=%u type=%u size=%u maxfield=%u report_count=%u\n", report->id, report->type, report->size, report->maxfield, report->field[0]->report_count); } dbg_hid("Found all reports\n"); /* Create the LED structures */ for (i = 0; i < LED_COUNT; i++) { data->led_cdev[i] = kzalloc(sizeof(struct led_classdev), GFP_KERNEL); if (data->led_cdev[i] == NULL) { dev_err(&hdev->dev, G19_NAME " error allocating memory for led %d", i); error = -ENOMEM; goto err_cleanup_led_structs; } /* Set the accessor functions by copying from template*/ *(data->led_cdev[i]) = g19_led_cdevs[i]; /* * Allocate memory for the LED name * * Since led_classdev->name is a const char* we'll use an * intermediate until the name is formatted with sprintf(). */ led_name = kzalloc(sizeof(char)*20, GFP_KERNEL); if (led_name == NULL) { dev_err(&hdev->dev, G19_NAME " error allocating memory for led %d name", i); error = -ENOMEM; goto err_cleanup_led_structs; } switch (i) { case G19_LED_M1: case G19_LED_M2: case G19_LED_M3: sprintf(led_name, "g19_%d:orange:m%d", hdev->minor, i+1); break; case G19_LED_MR: sprintf(led_name, "g19_%d:red:mr", hdev->minor); break; case G19_LED_BL_R: sprintf(led_name, "g19_%d:red:bl", hdev->minor); break; case G19_LED_BL_G: sprintf(led_name, "g19_%d:green:bl", hdev->minor); break; case G19_LED_BL_B: sprintf(led_name, "g19_%d:blue:bl", hdev->minor); break; case G19_LED_BL_SCREEN: sprintf(led_name, "g19_%d:white:screen", hdev->minor); break; } data->led_cdev[i]->name = led_name; } for (i = 0; i < LED_COUNT; i++) { led_num = i; error = led_classdev_register(&hdev->dev, data->led_cdev[i]); if (error < 0) { dev_err(&hdev->dev, G19_NAME " error registering led %d", i); error = -EINVAL; goto err_cleanup_registered_leds; } } data->gfb_data = gfb_probe(hdev, GFB_PANEL_TYPE_320_240_16); if (data->gfb_data == NULL) { dev_err(&hdev->dev, G19_NAME " error registering framebuffer\n"); goto err_cleanup_registered_leds; } dbg_hid("Waiting for G19 to activate\n"); /* Add the sysfs attributes */ error = sysfs_create_group(&(hdev->dev.kobj), &g19_attr_group); if (error) { dev_err(&hdev->dev, G19_NAME " failed to create sysfs group attributes\n"); goto err_cleanup_registered_leds; } /* * Wait here for stage 1 (substages 1-3) to complete */ wait_for_completion_timeout(&data->ready, HZ); /* Protect data->ready_stages before checking whether we're ready to proceed */ spin_lock_irqsave(&data->lock, irq_flags); if (data->ready_stages != G19_READY_STAGE_1) { dev_warn(&hdev->dev, G19_NAME " hasn't completed stage 1 yet, forging ahead with initialization\n"); /* Force the stage */ data->ready_stages = G19_READY_STAGE_1; } init_completion(&data->ready); data->ready_stages |= G19_READY_SUBSTAGE_4; spin_unlock_irqrestore(&data->lock, irq_flags); /* * Send the init report, then follow with the input report to trigger * report 6 and wait for us to get a response. */ g19_feature_report_4_send(hdev, G19_REPORT_4_INIT); usbhid_submit_report(hdev, data->start_input_report, USB_DIR_IN); wait_for_completion_timeout(&data->ready, HZ); /* Protect data->ready_stages before checking whether we're ready to proceed */ spin_lock_irqsave(&data->lock, irq_flags); if (data->ready_stages != G19_READY_STAGE_2) { dev_warn(&hdev->dev, G19_NAME " hasn't completed stage 2 yet, forging ahead with initialization\n"); /* Force the stage */ data->ready_stages = G19_READY_STAGE_2; } init_completion(&data->ready); data->ready_stages |= G19_READY_SUBSTAGE_6; spin_unlock_irqrestore(&data->lock, irq_flags); /* * Clear the LEDs */ g19_led_send(hdev); data->rgb[0] = G19_DEFAULT_RED; data->rgb[1] = G19_DEFAULT_GREEN; data->rgb[2] = G19_DEFAULT_BLUE; g19_rgb_send(hdev); data->screen_bl = G19_DEFAULT_BRIGHTNESS; g19_screen_bl_send(hdev); /* * Send the finalize report, then follow with the input report to trigger * report 6 and wait for us to get a response. */ g19_feature_report_4_send(hdev, G19_REPORT_4_FINALIZE); usbhid_submit_report(hdev, data->start_input_report, USB_DIR_IN); usbhid_submit_report(hdev, data->start_input_report, USB_DIR_IN); wait_for_completion_timeout(&data->ready, HZ); /* Protect data->ready_stages before checking whether we're ready to proceed */ spin_lock_irqsave(&data->lock, irq_flags); if (data->ready_stages != G19_READY_STAGE_3) { dev_warn(&hdev->dev, G19_NAME " hasn't completed stage 3 yet, forging ahead with initialization\n"); /* Force the stage */ data->ready_stages = G19_READY_STAGE_3; } else { dbg_hid(G19_NAME " stage 3 complete\n"); } spin_unlock_irqrestore(&data->lock, irq_flags); g19_set_keymap_switching(hdev, 1); g19_ep1_read(hdev); dbg_hid("G19 activated and initialized\n"); /* Everything went well */ return 0; err_cleanup_registered_leds: for (i = 0; i < led_num; i++) led_classdev_unregister(data->led_cdev[i]); err_cleanup_led_structs: for (i = 0; i < LED_COUNT; i++) { if (data->led_cdev[i] != NULL) { if (data->led_cdev[i]->name != NULL) kfree(data->led_cdev[i]->name); kfree(data->led_cdev[i]); } } err_cleanup_input_dev_reg: input_unregister_device(data->input_dev); err_cleanup_input_dev: input_free_device(data->input_dev); err_cleanup_ep1_urb: usb_free_urb(data->ep1_urb); err_cleanup_data: /* Make sure we clean up the allocated data structure */ kfree(data); err_no_cleanup: hid_set_drvdata(hdev, NULL); return error; }
static int __devinit lm3530_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct lm3530_platform_data *pdata = client->dev.platform_data; struct lm3530_data *drvdata; int err = 0; if (pdata == NULL) { dev_err(&client->dev, "platform data required\n"); return -ENODEV; } /* BL mode */ if (pdata->mode > LM3530_BL_MODE_PWM) { dev_err(&client->dev, "Illegal Mode request\n"); return -EINVAL; } if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { dev_err(&client->dev, "I2C_FUNC_I2C not supported\n"); return -EIO; } drvdata = devm_kzalloc(&client->dev, sizeof(struct lm3530_data), GFP_KERNEL); if (drvdata == NULL) return -ENOMEM; drvdata->mode = pdata->mode; drvdata->client = client; drvdata->pdata = pdata; drvdata->brightness = LED_OFF; drvdata->enable = false; drvdata->led_dev.name = LM3530_LED_DEV; drvdata->led_dev.brightness_set = lm3530_brightness_set; drvdata->led_dev.max_brightness = MAX_BRIGHTNESS; i2c_set_clientdata(client, drvdata); drvdata->regulator = regulator_get(&client->dev, "vin"); if (IS_ERR(drvdata->regulator)) { dev_err(&client->dev, "regulator get failed\n"); err = PTR_ERR(drvdata->regulator); drvdata->regulator = NULL; return err; } if (drvdata->pdata->brt_val) { err = lm3530_init_registers(drvdata); if (err < 0) { dev_err(&client->dev, "Register Init failed: %d\n", err); err = -ENODEV; goto err_reg_init; } } err = led_classdev_register(&client->dev, &drvdata->led_dev); if (err < 0) { dev_err(&client->dev, "Register led class failed: %d\n", err); err = -ENODEV; goto err_class_register; } err = device_create_file(drvdata->led_dev.dev, &dev_attr_mode); if (err < 0) { dev_err(&client->dev, "File device creation failed: %d\n", err); err = -ENODEV; goto err_create_file; } return 0; err_create_file: led_classdev_unregister(&drvdata->led_dev); err_class_register: err_reg_init: regulator_put(drvdata->regulator); return err; }
static int tcc8800_backlight_remove(struct platform_device *pdev) { led_classdev_unregister(&tcc8800_backlight_led); return 0; }
static int __devexit msm_pmic_led_remove(struct platform_device *pdev) { led_classdev_unregister(&msm_kp_bl_led); return 0; }
static int __devinit pm8xxx_led_probe(struct platform_device *pdev) { const struct led_platform_data *pcore_data; struct led_info *curr_led; struct pm8xxx_led_config *led_cfg; struct pm8xxx_led_data *led, *led_dat; struct leds_dev_data *info; struct pm8xxx_led_platform_data *pdata ; int rc = -1, i = 0; pdata = pdev->dev.platform_data; if (pdata == NULL) { dev_err(&pdev->dev, "platform data not supplied\n"); return -EINVAL; } pcore_data = pdata->led_core; if (pcore_data->num_leds != pdata->num_configs) { dev_err(&pdev->dev, "#no. of led configs and #no. of led" "entries are not equal\n"); return -EINVAL; } led = kcalloc(pcore_data->num_leds, sizeof(*led), GFP_KERNEL); if (led == NULL) { dev_err(&pdev->dev, "failed to alloc memory\n"); return -ENOMEM; } info = kzalloc(sizeof(*info), GFP_KERNEL); if (!info) { dev_err(&pdev->dev, "fail to memory allocation.\n"); rc = -ENOMEM; goto fail_mem_check; } info->pdata = pdata; info->led = led; for (i = 0; i < pcore_data->num_leds; i++) { curr_led = &pcore_data->leds[i]; led_dat = &led[i]; led_cfg = &pdata->configs[i]; led_dat->id = led_cfg->id; led_dat->pwm_channel = led_cfg->pwm_channel; led_dat->pwm_period_us = led_cfg->pwm_period_us; led_dat->pwm_duty_cycles = led_cfg->pwm_duty_cycles; if (!((led_dat->id >= PM8XXX_ID_LED_KB_LIGHT) && (led_dat->id <= PM8XXX_ID_FLASH_LED_1))) { dev_err(&pdev->dev, "invalid LED ID (%d) specified\n", led_dat->id); rc = -EINVAL; goto fail_id_check; } led_dat->cdev.name = curr_led->name; led_dat->cdev.default_trigger = curr_led->default_trigger; led_dat->cdev.brightness_set = pm8xxx_led_set; led_dat->cdev.brightness_get = pm8xxx_led_get; led_dat->cdev.brightness = LED_OFF; led_dat->cdev.flags = curr_led->flags; led_dat->dev = &pdev->dev; rc = get_init_value(led_dat, &led_dat->reg); if (rc < 0) goto fail_id_check; rc = pm8xxx_set_led_mode_and_max_brightness(led_dat, led_cfg->mode, led_cfg->max_current); if (rc < 0) goto fail_id_check; mutex_init(&led_dat->lock); INIT_WORK(&led_dat->work, pm8xxx_led_work); if (led_dat->id == PM8XXX_ID_LED_KB_LIGHT) __pm8xxx_led_work(led_dat, LED_FULL); else __pm8xxx_led_work(led_dat, LED_OFF); } platform_set_drvdata(pdev, info); led_virtual_dev(info); low_powermode = 0; return 0; fail_id_check: if (i > 0) { for (i = i - 1; i >= 0; i--) { mutex_destroy(&led[i].lock); led_classdev_unregister(&led[i].cdev); if (led[i].pwm_dev != NULL) pwm_free(led[i].pwm_dev); } } kfree(info); fail_mem_check: kfree(led); return rc; }
static int SN3193_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret=0; int i; struct SN3193_sled * sn3193_sled_dev; //client->dev.platform_data = &rgb_pdata; SN3193_power(); msleep(100); if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("%s : need I2C_FUNC_I2C\n", __func__); return -ENODEV; } SN3193_sled_dev_sate->gi2c_dev=client; sn3193_sled_dev = kzalloc(sizeof(struct SN3193_sled), GFP_KERNEL); if (sn3193_sled_dev == NULL) { dev_err(&client->dev, "failed to allocate memory for module data\n"); ret = -ENOMEM; goto err_exit; } pr_info("%s:sn3193 probe\n",__func__); sn3193_sled_dev->i2c_dev = client; sn3193_sled_dev->SN3193_miscdev.minor = MISC_DYNAMIC_MINOR; sn3193_sled_dev->SN3193_miscdev.name = "SN3193"; sn3193_sled_dev->SN3193_miscdev.fops = &SN3193_fops; ret = misc_register(&sn3193_sled_dev->SN3193_miscdev); if (ret) { pr_err("%s : misc_register failed\n", __FILE__); goto err_misc_register; } for(i = 0; i < 3; i ++ ) { if (led_classdev_register(&client->dev, &SN3193_lcds[i])) { printk(KERN_ERR "led_classdev_register failed of SN3193_lcds!\n"); goto err_classdev_register; } } ret = sysfs_create_group(&client->dev.kobj, &blink_attr_group); if (ret) { pr_err( "%s : sysfs_create_group failed!\n", __func__); goto err_group_register; } i2c_set_clientdata(client, sn3193_sled_dev); //SN3193_config_feature_sled(0); //dvt not breath //close, light as need SN3193_SetBrightness(RED_SLED,0); SN3193_SetBrightness(GREEN_SLED,0); SN3193_SetBrightness(BLUE_SLED,0); SN3193_upData_sled(); SN3193_TurnOffOut_sled(); SN3193_enable_sled(0); /**************************test*********************/ //enable sled /*SN3193_enable_sled(1); SN3193_config_feature_sled(0x00); SN3193_workmod_sled(1); SN3193_setCurrent_sled(0x01);*/ //SN3193_enable_diff_color_sled(BLUE_SLED); //mod_timer(&SN3193_sled_dev_sate->gsled_last_timer,jiffies+5*HZ); /**************************test******************/ return 0; err_group_register: for(i = 0; i < 3; i ++ ) led_classdev_unregister(&SN3193_lcds[i]); err_classdev_register: misc_deregister(&sn3193_sled_dev->SN3193_miscdev); err_misc_register: kfree(sn3193_sled_dev); err_exit: return ret; }
static int __devinit lm3530_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct lm3530_platform_data *pdata = client->dev.platform_data; struct lm3530_data *drvdata; int err = 0; if (pdata == NULL) { dev_err(&client->dev, "platform data required\n"); err = -ENODEV; goto err_out; } /* BL mode */ if (pdata->mode > LM3530_BL_MODE_PWM) { dev_err(&client->dev, "Illegal Mode request\n"); err = -EINVAL; goto err_out; } if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { dev_err(&client->dev, "I2C_FUNC_I2C not supported\n"); err = -EIO; goto err_out; } drvdata = kzalloc(sizeof(struct lm3530_data), GFP_KERNEL); if (drvdata == NULL) { err = -ENOMEM; goto err_out; } drvdata->mode = pdata->mode; drvdata->client = client; drvdata->pdata = pdata; drvdata->led_dev.name = LM3530_LED_DEV; drvdata->led_dev.brightness_set = lm3530_brightness_set; i2c_set_clientdata(client, drvdata); err = lm3530_init_registers(drvdata); if (err < 0) { dev_err(&client->dev, "Register Init failed: %d\n", err); err = -ENODEV; goto err_reg_init; } err = led_classdev_register((struct device *) &client->dev, &drvdata->led_dev); if (err < 0) { dev_err(&client->dev, "Register led class failed: %d\n", err); err = -ENODEV; goto err_class_register; } err = device_create_file(drvdata->led_dev.dev, &dev_attr_mode); if (err < 0) { dev_err(&client->dev, "File device creation failed: %d\n", err); err = -ENODEV; goto err_create_file; } return 0; err_create_file: led_classdev_unregister(&drvdata->led_dev); err_class_register: err_reg_init: kfree(drvdata); err_out: return err; }
static int adp8870_led_probe(struct i2c_client *client) { struct adp8870_backlight_platform_data *pdata = client->dev.platform_data; struct adp8870_bl *data = i2c_get_clientdata(client); struct adp8870_led *led, *led_dat; struct led_info *cur_led; int ret, i; led = devm_kzalloc(&client->dev, pdata->num_leds * sizeof(*led), GFP_KERNEL); if (led == NULL) { dev_err(&client->dev, "failed to alloc memory\n"); return -ENOMEM; } ret = adp8870_write(client, ADP8870_ISCLAW, pdata->led_fade_law); if (ret) return ret; ret = adp8870_write(client, ADP8870_ISCT1, (pdata->led_on_time & 0x3) << 6); if (ret) return ret; ret = adp8870_write(client, ADP8870_ISCF, FADE_VAL(pdata->led_fade_in, pdata->led_fade_out)); if (ret) return ret; for (i = 0; i < pdata->num_leds; ++i) { cur_led = &pdata->leds[i]; led_dat = &led[i]; led_dat->id = cur_led->flags & ADP8870_FLAG_LED_MASK; if (led_dat->id > 7 || led_dat->id < 1) { dev_err(&client->dev, "Invalid LED ID %d\n", led_dat->id); goto err; } if (pdata->bl_led_assign & (1 << (led_dat->id - 1))) { dev_err(&client->dev, "LED %d used by Backlight\n", led_dat->id); goto err; } led_dat->cdev.name = cur_led->name; led_dat->cdev.default_trigger = cur_led->default_trigger; led_dat->cdev.brightness_set = adp8870_led_set; led_dat->cdev.brightness = LED_OFF; led_dat->flags = cur_led->flags >> FLAG_OFFT_SHIFT; led_dat->client = client; led_dat->new_brightness = LED_OFF; INIT_WORK(&led_dat->work, adp8870_led_work); ret = led_classdev_register(&client->dev, &led_dat->cdev); if (ret) { dev_err(&client->dev, "failed to register LED %d\n", led_dat->id); goto err; } ret = adp8870_led_setup(led_dat); if (ret) { dev_err(&client->dev, "failed to write\n"); i++; goto err; } } data->led = led; return 0; err: for (i = i - 1; i >= 0; --i) { led_classdev_unregister(&led[i].cdev); cancel_work_sync(&led[i].work); } return ret; }
static int qpnp_wled_probe(struct spmi_device *spmi) { struct qpnp_wled *wled; struct resource *wled_resource; int rc, i; wled = devm_kzalloc(&spmi->dev, sizeof(*wled), GFP_KERNEL); if (!wled) return -ENOMEM; wled->spmi = spmi; wled_resource = spmi_get_resource_byname(spmi, NULL, IORESOURCE_MEM, QPNP_WLED_SINK_BASE); if (!wled_resource) { dev_err(&spmi->dev, "Unable to get wled sink base address\n"); return -EINVAL; } wled->sink_base = wled_resource->start; wled_resource = spmi_get_resource_byname(spmi, NULL, IORESOURCE_MEM, QPNP_WLED_CTRL_BASE); if (!wled_resource) { dev_err(&spmi->dev, "Unable to get wled ctrl base address\n"); return -EINVAL; } wled->ctrl_base = wled_resource->start; wled_resource = spmi_get_resource_byname(spmi, NULL, IORESOURCE_MEM, QPNP_WLED_IBB_BASE); if (!wled_resource) { dev_err(&spmi->dev, "Unable to get IBB base address\n"); return -EINVAL; } wled->ibb_base = wled_resource->start; wled_resource = spmi_get_resource_byname(spmi, NULL, IORESOURCE_MEM, QPNP_WLED_LAB_BASE); if (!wled_resource) { dev_err(&spmi->dev, "Unable to get LAB base address\n"); return -EINVAL; } wled->lab_base = wled_resource->start; dev_set_drvdata(&spmi->dev, wled); rc = qpnp_wled_parse_dt(wled); if (rc) { dev_err(&spmi->dev, "DT parsing failed\n"); return rc; } rc = qpnp_wled_config(wled); if (rc) { dev_err(&spmi->dev, "wled config failed\n"); return rc; } mutex_init(&wled->lock); INIT_WORK(&wled->work, qpnp_wled_work); wled->ramp_ms = QPNP_WLED_RAMP_DLY_MS; wled->ramp_step = 1; wled->cdev.brightness_set = qpnp_wled_set; wled->cdev.brightness_get = qpnp_wled_get; if (wled->en_9b_dim_res) wled->cdev.max_brightness = WLED_MAX_LEVEL_511; else wled->cdev.max_brightness = WLED_MAX_LEVEL_4095; rc = led_classdev_register(&spmi->dev, &wled->cdev); if (rc) { dev_err(&spmi->dev, "wled registration failed(%d)\n", rc); goto wled_register_fail; } for (i = 0; i < ARRAY_SIZE(qpnp_wled_attrs); i++) { rc = sysfs_create_file(&wled->cdev.dev->kobj, &qpnp_wled_attrs[i].attr); if (rc < 0) { dev_err(&spmi->dev, "sysfs creation failed\n"); goto sysfs_fail; } } gwled = wled; return 0; sysfs_fail: for (i--; i >= 0; i--) sysfs_remove_file(&wled->cdev.dev->kobj, &qpnp_wled_attrs[i].attr); led_classdev_unregister(&wled->cdev); wled_register_fail: cancel_work_sync(&wled->work); mutex_destroy(&wled->lock); return rc; }
static int clevo_mail_led_remove(struct platform_device *pdev) { led_classdev_unregister(&clevo_mail_led); return 0; }
static int fbx_leds_pwm_probe(struct platform_device *pdev) { struct leds_fbx_pwm_platform_data *fbx_leds_pwm_pd = pdev->dev.platform_data; int ret = 0; int i = 0; fbx_leds_pwm_dd = kzalloc(sizeof(struct fbx_leds_pwm_driver_data), GFP_KERNEL); if (fbx_leds_pwm_dd == NULL) { dev_err(&pdev->dev, "%s: no memory for device\n", __func__); ret = -ENOMEM; return ret; } memset(fbx_leds_pwm_dd, 0, sizeof(struct fbx_leds_pwm_driver_data)); fbx_leds_pwm_dd->r_led_ctl = fbx_leds_pwm_pd->r_led_ctl; fbx_leds_pwm_dd->leds[FBX_R_LED].name = "red"; fbx_leds_pwm_dd->leds[FBX_G_LED].name = "green"; fbx_leds_pwm_dd->leds[FBX_CAPS_KEY_LED].name = "button-backlight"; fbx_leds_pwm_dd->pause_lo_ms = 2000; fbx_leds_pwm_dd->pause_hi_ms = 500; fbx_leds_pwm_dd->blink_once = 0; mutex_init(&fbx_leds_pwm_dd->led_state_lock); mutex_lock(&fbx_leds_pwm_dd->led_state_lock); for (i = 0; i < 3; i++) { fbx_leds_pwm_dd->leds[i].brightness_set = fbx_leds_pwm_led_brightness_set; ret = led_classdev_register(&pdev->dev, &fbx_leds_pwm_dd->leds[i]); if (ret) { dev_err(&pdev->dev, "%s: led_classdev_register failed\n", __func__); goto err_led_classdev_register_failed; } dev_info(&pdev->dev, "%s: LED name(%s) was registered\n", __func__, fbx_leds_pwm_dd->leds[i].name); fbx_leds_pwm_dd->led_state[i] = FBX_LED_OFF; } mutex_unlock(&fbx_leds_pwm_dd->led_state_lock); for (i = 0; i < 3; i++) { ret = device_create_file(fbx_leds_pwm_dd->leds[i].dev, &dev_attr_blink); if (ret) { dev_err(&pdev->dev, "%s: device_create_file failed\n", __func__); for (i = 0; i < 3; i++) device_remove_file(fbx_leds_pwm_dd->leds[i].dev, &dev_attr_blink); return ret; } } ret = device_create_file(&pdev->dev, &dev_attr_ledon); if (ret) { dev_err(&pdev->dev, "%s: create dev_attr_ledon failed\n", __func__); goto err_out_attr_ledon; } ret = device_create_file(&pdev->dev, &dev_attr_ledoff); if (ret) { dev_err(&pdev->dev, "%s: create dev_attr_ledoff failed\n", __func__); goto err_out_attr_ledoff; } ret = device_create_file(&pdev->dev, &dev_attr_blink_once); if (ret) { dev_err(&pdev->dev, "%s: create dev_attr_blink_once failed\n", __func__); goto err_out_attr_blink_once; } dev_set_drvdata(&pdev->dev, fbx_leds_pwm_dd); fbx_leds_pwm_dd->pwm[0] = pwm_request(LPG_LED_DRV0, "red"); fbx_leds_pwm_dd->pwm[1] = pwm_request(LPG_LED_DRV1, "green"); fbx_leds_pwm_dd->pwm[2] = pwm_request(LPG_LED_DRV2, "button-backlight"); for (i = 0; i < 3; i++) { if (fbx_leds_pwm_dd->pwm[i] == NULL) { dev_err(&pdev->dev, "%s: pwm_request failed. LPG[%d]\n", __func__, LPG_LED_DRV0 + i); for (i = 0; i < 3; i++) { pwm_free(fbx_leds_pwm_dd->pwm[i]); goto err_out_pwm_request; } } } for (i = 0; i < 64; i++) fbx_leds_pwm_dd->duty_pct[i] = i; dev_info(&pdev->dev, "%s finished!!\n", __func__); return 0; err_out_pwm_request: device_remove_file(&pdev->dev, &dev_attr_blink_once); err_out_attr_blink_once: device_remove_file(&pdev->dev, &dev_attr_ledoff); err_out_attr_ledoff: device_remove_file(&pdev->dev, &dev_attr_ledon); err_out_attr_ledon: for (i = 0; i < 3; i++) device_remove_file(fbx_leds_pwm_dd->leds[i].dev, &dev_attr_blink); err_led_classdev_register_failed: for (i = 0; i < 3; i++) led_classdev_unregister(&fbx_leds_pwm_dd->leds[i]); mutex_destroy(&fbx_leds_pwm_dd->led_state_lock); kfree(fbx_leds_pwm_dd); return ret; }