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;
}
Exemplo n.º 3
0
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;
}
Exemplo n.º 4
0
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;
}
Exemplo n.º 5
0
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;
}
Exemplo n.º 6
0
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;
}
Exemplo n.º 8
0
static void devm_led_classdev_release(struct device *dev, void *res)
{
	led_classdev_unregister(*(struct led_classdev **)res);
}
Exemplo n.º 9
0
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;
}
Exemplo n.º 11
0
static int wndr3700_usb_led_remove(struct platform_device *pdev)
{
	led_classdev_unregister(&wndr3700_usb_led);
	return 0;
}
Exemplo n.º 12
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;
}
Exemplo n.º 13
0
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;
}
Exemplo n.º 14
0
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;
}
Exemplo n.º 15
0
static void __exit dell_led_exit(void)
{
	led_classdev_unregister(&dell_led);

	led_off();
}
Exemplo n.º 16
0
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;
}
Exemplo n.º 19
0
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);
}
Exemplo n.º 20
0
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;
}
Exemplo n.º 21
0
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;
}
Exemplo n.º 22
0
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;
}
Exemplo n.º 24
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;
}
Exemplo n.º 26
0
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;
}
Exemplo n.º 27
0
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;
}
Exemplo n.º 28
0
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;
}
Exemplo n.º 30
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;
}