Esempio n. 1
0
/**
 * devm_led_classdev_register - resource managed led_classdev_register()
 * @parent: The device to register.
 * @led_cdev: the led_classdev structure for this device.
 */
int devm_led_classdev_register(struct device *parent,
			       struct led_classdev *led_cdev)
{
	struct led_classdev **dr;
	int rc;

	dr = devres_alloc(devm_led_classdev_release, sizeof(*dr), GFP_KERNEL);
	if (!dr)
		return -ENOMEM;

	rc = led_classdev_register(parent, led_cdev);
	if (rc) {
		devres_free(dr);
		return rc;
	}

	*dr = led_cdev;
	devres_add(parent, dr);

	return 0;
}
Esempio n. 2
0
static int omap_led_probe(struct platform_device *dev)
{
	struct omap_led_platform_data *pdata = dev->dev.platform_data;
	struct omap_led_config *leds = pdata->leds;
	int i, ret = 0;

	for (i = 0; ret >= 0 && i < pdata->nr_leds; i++) {
		omap_configure_led_gpio(leds[i].gpio);
		if (!leds[i].cdev.brightness_set)
			leds[i].cdev.brightness_set = omap_set_led_gpio;

		ret = led_classdev_register(&dev->dev, &leds[i].cdev);
	}

	if (ret < 0 && i > 1) {
		for (i = i - 2; i >= 0; i--)
			led_classdev_unregister(&leds[i].cdev);
	}

	return ret;
}
void iwl_leds_init(struct iwl_priv *priv)
{
	int mode = led_mode;
	int ret;

	if (mode == IWL_LED_DEFAULT)
		mode = priv->cfg->led_mode;

	priv->led.name = kasprintf(GFP_KERNEL, "%s-led",
				   wiphy_name(priv->hw->wiphy));
	priv->led.brightness_set = iwl_led_brightness_set;
	priv->led.blink_set = iwl_led_blink_set;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,30)
	priv->led.max_brightness = 1;
#endif

	switch (mode) {
	case IWL_LED_DEFAULT:
		WARN_ON(1);
		break;
	case IWL_LED_BLINK:
		priv->led.default_trigger =
			ieee80211_create_tpt_led_trigger(priv->hw,
					IEEE80211_TPT_LEDTRIG_FL_CONNECTED,
					iwl_blink, ARRAY_SIZE(iwl_blink));
		break;
	case IWL_LED_RF_STATE:
		priv->led.default_trigger =
			ieee80211_get_radio_led_name(priv->hw);
		break;
	}

	ret = led_classdev_register(&priv->pci_dev->dev, &priv->led);
	if (ret) {
		kfree(priv->led.name);
		return;
	}

	priv->led_registered = true;
}
Esempio n. 4
0
void ath_init_leds(struct ath_softc *sc)
{
	int ret;

	if (AR_SREV_9100(sc->sc_ah))
		return;

	if (!led_blink)
		sc->led_cdev.default_trigger =
			ieee80211_get_radio_led_name(sc->hw);

	snprintf(sc->led_name, sizeof(sc->led_name),
		"ath9k-%s", wiphy_name(sc->hw->wiphy));
	sc->led_cdev.name = sc->led_name;
	sc->led_cdev.brightness_set = ath_led_brightness;

	ret = led_classdev_register(wiphy_dev(sc->hw->wiphy), &sc->led_cdev);
	if (ret < 0)
		return;

	sc->led_registered = true;
}
Esempio n. 5
0
static int msm_pmic_led_probe(struct platform_device *pdev)
{
	int rc;

	rc = led_classdev_register(&pdev->dev, &msm_kp_bl_led);
	if (rc) {
		dev_err(&pdev->dev, "unable to register led class driver\n");
		return rc;
	}
#ifdef CONFIG_HUAWEI_LEDS_PMIC
    if( machine_is_msm8255_u8860lp()	
    || machine_is_msm8255_u8860_r()
	  ||machine_is_msm8255_u8860_51())
    {
        led_pwm_gpio_config();   
        bl_pwm = pwm_request(LED_PM_GPIO25_PWM_ID, "keypad backlight");
    }
#endif

	msm_keypad_bl_led_set(&msm_kp_bl_led, LED_OFF);
	return rc;
}
Esempio n. 6
0
static int sunfire_led_generic_probe(struct platform_device *pdev,
					       struct led_type *types)
{
	struct sunfire_drvdata *p;
	int i, err;

	if (pdev->num_resources != 1) {
		dev_err(&pdev->dev, "Wrong number of resources %d, should be 1\n",
		       pdev->num_resources);
		return -EINVAL;
	}

	p = devm_kzalloc(&pdev->dev, sizeof(*p), GFP_KERNEL);
	if (!p)
		return -ENOMEM;

	for (i = 0; i < NUM_LEDS_PER_BOARD; i++) {
		struct led_classdev *lp = &p->leds[i].led_cdev;

		p->leds[i].reg = (void __iomem *) pdev->resource[0].start;
		lp->name = types[i].name;
		lp->brightness = LED_FULL;
		lp->brightness_set = types[i].handler;
		lp->default_trigger = types[i].default_trigger;

		err = led_classdev_register(&pdev->dev, lp);
		if (err) {
			dev_err(&pdev->dev, "Could not register %s LED\n",
			       lp->name);
			for (i--; i >= 0; i--)
				led_classdev_unregister(&p->leds[i].led_cdev);
			return err;
		}
	}

	platform_set_drvdata(pdev, p);

	return 0;
}
static int __devinit aat1270_probe(struct platform_device *pdev)
{
	printk("aat1270_probe\n");

	aat1270_pdata = pdev->dev.platform_data;
/* [email protected] 2010.09.06 S
    add to avoid warning mesg in gpiolib
    */
#ifdef CONFIG_MACH_LGE_BRYCE
    gpio_request(aat1270_pdata->gpio_flen, "cam_flash_en");
	gpio_request(aat1270_pdata->gpio_en_set, "cam_flash_led_torch");
	gpio_request(aat1270_pdata->gpio_inh, "cam_flash_inhibit");
#endif	
/* [email protected] 2010.09.06 E */

	gpio_tlmm_config(GPIO_CFG(aat1270_pdata->gpio_flen, 0, GPIO_CFG_OUTPUT,
		GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
	gpio_tlmm_config(GPIO_CFG(aat1270_pdata->gpio_en_set, 0, GPIO_CFG_OUTPUT,
		GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
	gpio_tlmm_config(GPIO_CFG(aat1270_pdata->gpio_inh, 0, GPIO_CFG_OUTPUT,
		GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_ENABLE);

	gpio_direction_output(aat1270_pdata->gpio_flen, 0);
	gpio_direction_output(aat1270_pdata->gpio_en_set, 0);
	gpio_direction_output(aat1270_pdata->gpio_inh, 0);

	INIT_WORK(&work_flash_on, flash_on);
	INIT_WORK(&work_flash_off, flash_off);

	hrtimer_init(&flash_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
	flash_timer.function = flash_timer_func;

	led_classdev_register(&pdev->dev, &flash_led);

	timed_output_dev_register(&to_flash);
	
	return 0;
	
}
Esempio n. 8
0
int32_t msm_led_flashlight_create_classdev(struct platform_device *pdev,
				void *data)
{
	int32_t i, rc = 0;
	struct msm_led_flash_ctrl_t *fctrl =
		(struct msm_led_flash_ctrl_t *)data;

	if (!fctrl) {
		pr_err("Invalid fctrl\n");
		return -EINVAL;
	}

	g_fctrl = fctrl;

	rc = led_classdev_register(&pdev->dev, &msm_torch_led);
        if (rc) {
	        pr_err("Failed to register %d led dev. rc = %d\n", i, rc);
                return rc;
        }

	return 0;
};
Esempio n. 9
0
static int xpad_led_probe(struct usb_xpad *xpad)
{
	static atomic_t led_seq	= ATOMIC_INIT(0);
	long led_no;
	struct xpad_led *led;
	struct led_classdev *led_cdev;
	int error;

	if (xpad->xtype != XTYPE_XBOX360)
		return 0;

	xpad->led = led = kzalloc(sizeof(struct xpad_led), GFP_KERNEL);
	if (!led)
		return -ENOMEM;

	led_no = (long)atomic_inc_return(&led_seq) - 1;

	snprintf(led->name, sizeof(led->name), "xpad%ld", led_no);
	led->xpad = xpad;

	led_cdev = &led->led_cdev;
	led_cdev->name = led->name;
	led_cdev->brightness_set = xpad_led_set;

	error = led_classdev_register(&xpad->udev->dev, led_cdev);
	if (error) {
		kfree(led);
		xpad->led = NULL;
		return error;
	}

	/*
                                                           
  */
	xpad_send_led_command(xpad, (led_no % 4) + 2);

	return 0;
}
Esempio n. 10
0
File: xpad.c Progetto: 19Dan01/linux
static int xpad_led_probe(struct usb_xpad *xpad)
{
	static atomic_t led_seq	= ATOMIC_INIT(-1);
	unsigned long led_no;
	struct xpad_led *led;
	struct led_classdev *led_cdev;
	int error;

	if (xpad->xtype != XTYPE_XBOX360)
		return 0;

	xpad->led = led = kzalloc(sizeof(struct xpad_led), GFP_KERNEL);
	if (!led)
		return -ENOMEM;

	led_no = atomic_inc_return(&led_seq);

	snprintf(led->name, sizeof(led->name), "xpad%lu", led_no);
	led->xpad = xpad;

	led_cdev = &led->led_cdev;
	led_cdev->name = led->name;
	led_cdev->brightness_set = xpad_led_set;

	error = led_classdev_register(&xpad->udev->dev, led_cdev);
	if (error) {
		kfree(led);
		xpad->led = NULL;
		return error;
	}

	/*
	 * Light up the segment corresponding to controller number
	 */
	xpad_send_led_command(xpad, (led_no % 4) + 2);

	return 0;
}
Esempio n. 11
0
static int hw_lm3642_register_attribute(struct hw_flash_ctrl_t *flash_ctrl, struct device *dev)
{
	int rc = 0;

	if ((NULL == flash_ctrl) || (NULL == dev)) {
		cam_err("%s flash_ctrl or dev is NULL.", __func__);
		return -1;
	}

	flash_ctrl->cdev_torch.name = "torch";
	flash_ctrl->cdev_torch.max_brightness
		= ((struct hw_lm3642_private_data_t *)(flash_ctrl->pdata))->torch_led_num;
	flash_ctrl->cdev_torch.brightness_set = hw_lm3642_torch_brightness_set;
	rc = led_classdev_register((struct device *)dev, &flash_ctrl->cdev_torch);
	if (rc < 0) {
		cam_err("%s failed to register torch classdev.", __func__);
		goto err_out;
	}

	rc = device_create_file(dev, &hw_lm3642_lightness);
	if (rc < 0) {
		cam_err("%s failed to creat lightness attribute.", __func__);
		goto err_create_lightness_file;
	}

	rc = device_create_file(dev, &hw_lm3642_flash_mask);
	if (rc < 0) {
		cam_err("%s failed to creat flash_mask attribute.", __func__);
		goto err_create_flash_mask_file;
	}
	return 0;
err_create_flash_mask_file:
	device_remove_file(dev, &hw_lm3642_lightness);
err_create_lightness_file:
	led_classdev_unregister(&flash_ctrl->cdev_torch);
err_out:
	return rc;
}
Esempio n. 12
0
void ath_init_leds(struct ath_softc *sc)
{
	int ret;

	if (sc->sc_ah->led_pin < 0) {
		if (AR_SREV_9287(sc->sc_ah))
			sc->sc_ah->led_pin = ATH_LED_PIN_9287;
		else if (AR_SREV_9485(sc->sc_ah))
			sc->sc_ah->led_pin = ATH_LED_PIN_9485;
		else if (AR_SREV_9300(sc->sc_ah))
			sc->sc_ah->led_pin = ATH_LED_PIN_9300;
		else if (AR_SREV_9462(sc->sc_ah))
			sc->sc_ah->led_pin = ATH_LED_PIN_9462;
		else
			sc->sc_ah->led_pin = ATH_LED_PIN_DEF;
	}

	/* Configure gpio 1 for output */
	ath9k_btcoex_ath9k_hw_cfg_output(sc->sc_ah, sc->sc_ah->led_pin,
			    AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
	/* LED off, active low */
	ath9k_btcoex_ath9k_hw_set_gpio(sc->sc_ah, sc->sc_ah->led_pin, 1);

	if (!led_blink)
		sc->led_cdev.default_trigger =
			ieee80211_get_radio_led_name(sc->hw);

	snprintf(sc->led_name, sizeof(sc->led_name),
		"ath9k-%s", wiphy_name(sc->hw->wiphy));
	sc->led_cdev.name = sc->led_name;
	sc->led_cdev.brightness_set = ath_led_brightness;

	ret = led_classdev_register(wiphy_dev(sc->hw->wiphy), &sc->led_cdev);
	if (ret < 0)
		return;

	sc->led_registered = true;
}
Esempio n. 13
0
int32_t msm_led_torch_create_classdev(struct platform_device *pdev,
                                      void *data)
{
    int rc;
    struct msm_led_flash_ctrl_t *fctrl =
        (struct msm_led_flash_ctrl_t *)data;

    if (!fctrl || !fctrl->torch_trigger) {
        pr_err("Invalid fctrl or torch trigger\n");
        return -EINVAL;
    }

    torch_trigger = fctrl->torch_trigger;
    msm_led_torch_brightness_set(&msm_torch_led, LED_OFF);

    rc = led_classdev_register(&pdev->dev, &msm_torch_led);
    if (rc) {
        pr_err("Failed to register led dev. rc = %d\n", rc);
        return rc;
    }

    return 0;
};
Esempio n. 14
0
static int msm_pmic_led_probe(struct platform_device *pdev)
{
	int rc;
#if defined (CONFIG_LGE_UNIFIED_LED)
	leds_pdata = pdev->dev.platform_data;
#endif

#ifndef CONFIG_LGE_UNIFIED_LED
	if (pdev->dev.platform_data)
		msm_kp_bl_led.name = pdev->dev.platform_data;
#endif

	rc = led_classdev_register(&pdev->dev, &msm_kp_bl_led);
	if (rc) {
		dev_err(&pdev->dev, "unable to register led class driver\n");
		return rc;
	}
	msm_keypad_bl_led_set(&msm_kp_bl_led, LED_OFF);
#if defined (CONFIG_LGE_UNIFIED_LED)
	leds_pdata->register_custom_leds(pdev);
#endif
	return rc;
}
static int accton_as7312_54x_led_probe(struct platform_device *pdev)
{
    int ret, i;

    for (i = 0; i < ARRAY_SIZE(accton_as7312_54x_leds); i++) {
        ret = led_classdev_register(&pdev->dev, &accton_as7312_54x_leds[i]);

        if (ret < 0)
            break;
    }

    /* Check if all LEDs were successfully registered */
    if (i != ARRAY_SIZE(accton_as7312_54x_leds)) {
        int j;

        /* only unregister the LEDs that were successfully registered */
        for (j = 0; j < i; j++) {
            led_classdev_unregister(&accton_as7312_54x_leds[i]);
        }
    }

    return ret;
}
Esempio n. 16
0
static int omap4430_keypad_led_probe(struct platform_device *pdev)
{
	int ret;
	struct keypad_led_data *info;

	pr_info("%s:Enter\n", __func__);

	info = kzalloc(sizeof(struct keypad_led_data), GFP_KERNEL);
	if (info == NULL) {
		ret = -ENOMEM;
		return ret;
	}

	platform_set_drvdata(pdev, info);

	info->keypad_led_class_dev.name = "keyboard-backlight";
	info->keypad_led_class_dev.brightness_set =
			omap4430_keypad_led_store;
	info->keypad_led_class_dev.max_brightness = LED_FULL;

	ret = led_classdev_register(&pdev->dev,
				    &info->keypad_led_class_dev);
	if (ret < 0) {
		pr_err("%s: Register led class failed\n", __func__);
		kfree(info);
		return ret;
	}

	/*TO DO pass in these values from the board file */
	twl_i2c_write_u8(TWL_MODULE_PWM, 0xFF, KP_LED_PWM1ON);
	twl_i2c_write_u8(TWL_MODULE_PWM, 0x7f, KP_LED_PWM1OFF);
	twl_i2c_write_u8(TWL6030_MODULE_ID1, 0x06, KP_LED_TOGGLE3);

	pr_info("%s:Exit\n", __func__);

	return ret;
}
Esempio n. 17
0
static int __init shark_leds_init(void)
{
	int i;
	u16 reg;

	if (!machine_is_shark())
		return -ENODEV;

	for (i = 0; i < ARRAY_SIZE(shark_leds); i++) {
		struct shark_led *led;

		led = kzalloc(sizeof(*led), GFP_KERNEL);
		if (!led)
			break;

		led->cdev.name = shark_leds[i].name;
		led->cdev.brightness_set = shark_led_set;
		led->cdev.brightness_get = shark_led_get;
		led->cdev.default_trigger = shark_leds[i].trigger;

		/* Count in 5 bits offset */
		led->mask = BIT(i + 5);

		if (led_classdev_register(NULL, &led->cdev) < 0) {
			kfree(led);
			break;
		}
	}

	/* Make LEDs independent of power-state */
	request_region(0x24, 4, "led_reg");
	reg = led_reg_read();
	reg |= 1 << 10;
	led_reg_write(reg);

	return 0;
}
static int speedy_backlight_probe(struct platform_device *pdev)
{
	int err = -EIO;

	mutex_init(&cabc.lock);
	cabc.client_data = pdev->dev.platform_data;
	cabc.lcd_backlight.name = "lcd-backlight";
	cabc.lcd_backlight.brightness_set = speedy_set_brightness;
	cabc.lcd_backlight.brightness_get = speedy_get_brightness;
	err = led_classdev_register(&pdev->dev, &cabc.lcd_backlight);
	if (err)
		goto err_register_lcd_bl;

	err = device_create_file(cabc.lcd_backlight.dev, &auto_attr);
	if (err)
		goto err_out;

	return 0;
err_out:
	device_remove_file(&pdev->dev, &auto_attr);
err_register_lcd_bl:
	led_classdev_unregister(&cabc.lcd_backlight);
	return err;
}
Esempio n. 19
0
static int32_t msm_torch_create_classdev(struct platform_device *pdev,
				void *data)
{
	int32_t rc = 0;
	int32_t i = 0;
	struct msm_flash_ctrl_t *fctrl =
		(struct msm_flash_ctrl_t *)data;

	if (!fctrl) {
		pr_err("Invalid fctrl\n");
		return -EINVAL;
	}

	for (i = 0; i < fctrl->torch_num_sources; i++) {
		if (fctrl->torch_trigger[i]) {
			torch_trigger = fctrl->torch_trigger[i];
			CDBG("%s:%d msm_torch_brightness_set for torch %d",
				__func__, __LINE__, i);
			msm_torch_brightness_set(&msm_torch_led[i],
				LED_OFF);

			rc = led_classdev_register(&pdev->dev,
				&msm_torch_led[i]);
			if (rc) {
				pr_err("Failed to register %d led dev. rc = %d\n",
						i, rc);
				return rc;
			}
		} else {
			pr_err("Invalid fctrl->torch_trigger[%d]\n", i);
			return -EINVAL;
		}
	}

	return 0;
};
static int keyboard_led_probe(struct platform_device *pdev)
{
	struct led_classdev *cdev;
	acpi_handle handle;
	acpi_status status;
	int ret;

	/* Look for the keyboard LED ACPI Device */
	status = acpi_get_handle(ACPI_ROOT_OBJECT,
				 ACPI_KEYBOARD_BACKLIGHT_DEVICE,
				 &handle);
	if (ACPI_FAILURE(status)) {
		dev_err(&pdev->dev, "Unable fo find ACPI device %s\n",
			ACPI_KEYBOARD_BACKLIGHT_DEVICE);
		return -ENODEV;
	}

	cdev = kzalloc(sizeof(struct led_classdev), GFP_KERNEL);
	if (!cdev)
		return -ENOMEM;
	cdev->name = "chromeos::kbd_backlight";
	cdev->brightness_set = keyboard_led_set_brightness;
	cdev->max_brightness = ACPI_KEYBOARD_BACKLIGHT_MAX;
	cdev->brightness = cdev->max_brightness;
	cdev->flags |= LED_CORE_SUSPENDRESUME;

	ret = led_classdev_register(&pdev->dev, cdev);
	if (ret)
		goto err;

	platform_set_drvdata(pdev, cdev);
	return 0;
err:
	kfree(cdev);
	return ret;
}
Esempio n. 21
0
static int keypad_led_probe(struct platform_device *dev)
{
	struct omap_led_platform_data *pdata = dev->dev.platform_data;
	struct omap_led_config *leds = pdata->leds;
	int i, ret = 0;

	keypad_led_hardware_init();

	for (i = 0; ret >= 0 && i < pdata->nr_leds; i++) {
		if (!leds[i].cdev.brightness_set)
			leds[i].cdev.brightness_set = keypad_set_led;

		leds[i].cdev.brightness = 0;
		leds[i].cdev.flags = 0;

		ret = led_classdev_register(&dev->dev, &leds[i].cdev);
		if( ret < 0){
		    printk(" led %d register fail\n",i);
		    led_classdev_unregister(&leds[i].cdev);
	        }
	}

	return ret;
}
Esempio n. 22
0
int __init mahimahi_init_panel(void)
{
	int ret;

	if (!machine_is_mahimahi())
		return 0;

	if (system_rev > 0xC0) {
		
		init_tablep = samsung_oled_rgb666_init_table;
		init_table_sz = ARRAY_SIZE(samsung_oled_rgb666_init_table);
		mahimahi_lcdc_fb_data.output_format = MSM_MDP_OUT_IF_FMT_RGB666;
	}

	ret = platform_device_register(&msm_device_mdp);
	if (ret != 0)
		return ret;

	ret = mahimahi_init_spi_hack();
	if (ret != 0)
		return ret;

	INIT_WORK(&brightness_delayed_work, mahimahi_brightness_set_work);

	ret = platform_device_register(&mahimahi_lcdc_device);
	if (ret != 0)
		return ret;

	ret = led_classdev_register(NULL, &mahimahi_brightness_led);
	if (ret != 0) {
		pr_err("%s: Cannot register brightness led\n", __func__);
		return ret;
	}

	return 0;
}
static int max77828_rgb_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct max77828_rgb_platform_data *pdata;
	struct max77828_rgb *max77828_rgb;
	struct max77828_dev *max77828_dev = dev_get_drvdata(dev->parent);
	char temp_name[4][40] = {{0,},}, name[40] = {0,}, *p;
	int i, ret;

#ifdef CONFIG_OF
	pdata = max77828_rgb_parse_dt(dev);
	if (unlikely(IS_ERR(pdata)))
		return PTR_ERR(pdata);
#else
	pdata = dev_get_platdata(dev);
#endif
	pr_info("leds-max77828-rgb: %s\n", __func__);

	max77828_rgb = devm_kzalloc(dev, sizeof(struct max77828_rgb), GFP_KERNEL);
	if (unlikely(!max77828_rgb))
		return -ENOMEM;

	for (i = 0; i < 4; i++) {
		ret = snprintf(name, 30, "%s", pdata->name[i])+1;
		if (1 > ret)
			goto alloc_err_flash;

		p = devm_kzalloc(dev, ret, GFP_KERNEL);
		if (unlikely(!p))
			goto alloc_err_flash;

		strcpy(p, name);
		strcpy(temp_name[i], name);
		max77828_rgb->led[i].name = p;
		max77828_rgb->led[i].brightness_set = max77828_rgb_set;
		max77828_rgb->led[i].brightness_get = max77828_rgb_get;
		max77828_rgb->led[i].max_brightness = LED_MAX_CURRENT;

		ret = led_classdev_register(dev, &max77828_rgb->led[i]);
		if (IS_ERR_VALUE(ret)) {
			dev_err(dev, "unable to register RGB : %d\n", ret);
			goto alloc_err_flash_plus;
		}
		ret = sysfs_create_group(&max77828_rgb->led[i].dev->kobj,
						&common_led_attr_group);
		if (ret < 0) {
			dev_err(dev, "can not register sysfs attribute\n");
			goto register_err_flash;
		}
	}

	led_dev = sec_device_create(max77828_rgb, "led");
	if (IS_ERR(led_dev)) {
		dev_err(dev, "Failed to create device for samsung specific led\n");
		goto alloc_err_flash;
	}

	ret = sysfs_create_group(&led_dev->kobj, &sec_led_attr_group);
	if (ret < 0) {
		dev_err(dev, "Failed to create sysfs group for samsung specific led\n");
		goto alloc_err_flash;
	}

	platform_set_drvdata(pdev, max77828_rgb);

	max77828_rgb->i2c = max77828_dev->led;

	return 0;

register_err_flash:
	led_classdev_unregister(&max77828_rgb->led[i]);
alloc_err_flash_plus:
	devm_kfree(dev, temp_name[i]);
alloc_err_flash:
	while (i--) {
		led_classdev_unregister(&max77828_rgb->led[i]);
		devm_kfree(dev, temp_name[i]);
	}
	devm_kfree(dev, max77828_rgb);
	return -ENOMEM;
}
static int __init lm3530_probe(struct i2c_client *i2c_dev, const struct i2c_device_id *i2c_dev_id)
{
	struct lm3530_platform_data *pdata;
	struct lm3530_driver_data *drvdata;
	struct backlight_device *bd;
	int err;

	dprintk("start, client addr=0x%x\n", i2c_dev->addr);

	pdata = i2c_dev->dev.platform_data;
	if(!pdata)
		return -EINVAL;
		
	drvdata = kzalloc(sizeof(struct lm3530_driver_data), GFP_KERNEL);
	if (!drvdata) {
		dev_err(&i2c_dev->dev, "failed to allocate memory\n");
		return -ENOMEM;
	}

	if (pdata && pdata->platform_init)
		pdata->platform_init();

	drvdata->client = i2c_dev;
	drvdata->gpio = pdata->gpio;
	drvdata->max_intensity = LCD_LED_MAX;
	if (pdata->max_current > 0)
		drvdata->max_intensity = pdata->max_current;
	drvdata->intensity = LCD_LED_MIN;
	drvdata->mode = NORMAL_MODE;
	drvdata->state = UNINIT_STATE;
	drvdata->version = pdata->version;

	if(lge_bd_rev < LGE_REV_C) 
		exponential_eable = 1;
	else
		exponential_eable = 0;

	if(lm3530_setup_version(drvdata) != 0) {
		eprintk("Error while requesting gpio %d\n", drvdata->gpio);
		kfree(drvdata);
		return -ENODEV;
	}		
	if (drvdata->gpio && gpio_request(drvdata->gpio, "lm3530_en") != 0) {
		eprintk("Error while requesting gpio %d\n", drvdata->gpio);
		kfree(drvdata);
		return -ENODEV;
	}

	bd = backlight_device_register("lm3530-bl", &i2c_dev->dev, NULL, &lm3530_ops, NULL);
	if (bd == NULL) {
		eprintk("entering lm3530 probe function error \n");
		if (gpio_is_valid(drvdata->gpio))
			gpio_free(drvdata->gpio);
		kfree(drvdata);
		return -1;
	}
	bd->props.power = FB_BLANK_UNBLANK;
	bd->props.brightness = drvdata->intensity;
	bd->props.max_brightness = drvdata->max_intensity;
	drvdata->bd = bd;

#ifdef CONFIG_BACKLIGHT_LEDS_CLASS
	if (led_classdev_register(&i2c_dev->dev, &lm3530_led_dev) == 0) {
		eprintk("Registering led class dev successfully.\n");
		drvdata->led = &lm3530_led_dev;
		err = device_create_file(drvdata->led->dev, &dev_attr_alc);
		err = device_create_file(drvdata->led->dev, &dev_attr_reg);
		err = device_create_file(drvdata->led->dev, &dev_attr_drvstat);
	}
#endif

	i2c_set_clientdata(i2c_dev, drvdata);
	i2c_set_adapdata(i2c_dev->adapter, i2c_dev);

	lm3530_device_init(drvdata);
	if(exponential_eable)
		lm3530_send_intensity(drvdata, DEFAULT_BRIGHTNESS_EXPONENTIAL);
	else
		lm3530_send_intensity(drvdata, DEFAULT_BRIGHTNESS);

#ifdef CONFIG_HAS_EARLYSUSPEND
	drvdata->early_suspend.suspend = lm3530_early_suspend;
	drvdata->early_suspend.resume = lm3530_late_resume;
	drvdata->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN - 40;
	register_early_suspend(&drvdata->early_suspend);
#endif

	eprintk("done\n");
	return 0;
}
Esempio n. 25
0
static int lm3530_probe(struct i2c_client *client,
			   const struct i2c_device_id *id)
{
	struct lm3530_platform_data *pdata = dev_get_platdata(&client->dev);
	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;
	drvdata->led_dev.groups = lm3530_groups;

	i2c_set_clientdata(client, drvdata);

	drvdata->regulator = devm_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);
			return err;
		}
	}
	err = led_classdev_register(&client->dev, &drvdata->led_dev);
	if (err < 0) {
		dev_err(&client->dev, "Register led class failed: %d\n", err);
		return err;
	}

	return 0;
}
static int archer_led_probe(struct platform_device *pdev)
{	

	struct led_platform_data *pdata = pdev->dev.platform_data;
	struct led_info *cur_led;
	struct archer_led_data *leds_data, *led_dat;
	
	int i, ret = 0;

	printk("[LED] %s +\n", __func__);

	if (!pdata)
		return -EBUSY;

	leds_data = kzalloc(sizeof(struct archer_led_data) * pdata->num_leds,
				GFP_KERNEL);
	if (!leds_data)
		return -ENOMEM;

	for (i = 0; i < pdata->num_leds; i++) {
		cur_led = &pdata->leds[i];
		led_dat = &leds_data[i];
		printk("[LED] %s hw_revision=%d \n", __func__, hw_revision);
		if(hw_revision < 3 ) 
		{
			vmmc2 = regulator_get( &pdev->dev, "vmmc2" );
			if( IS_ERR( vmmc2 ) )
			{
				printk("PSENSOR: %s: regulator_get failed to get vmmc2!\n", __func__);
				goto err;
			}
		}
		else 
		{
			ret = gpio_request(OMAP_GPIO_LED_EN, cur_led->name);
			if (ret < 0)
				goto err;
			led_dat->gpio = OMAP_GPIO_LED_EN;
			led_dat->can_sleep = gpio_cansleep(OMAP_GPIO_LED_EN);
			gpio_direction_output(OMAP_GPIO_LED_EN, 1);

			ret = twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0x00, TWL4030_VMMC2_DEV_GRP);
			if (ret)
				printk(" leds-archer.c fail to set reousrce off TWL4030_VMMC2_DEV_GRP\n");
		}


		led_dat->cdev.name = cur_led->name;
		led_dat->cdev.default_trigger = cur_led->default_trigger;
		led_dat->cdev.brightness_set = archer_led_set;
		led_dat->cdev.brightness = LED_OFF;
		led_dat->cdev.flags |= LED_CORE_SUSPENDRESUME;

//		gpio_direction_output(led_dat->gpio, led_dat->active_low);

//		INIT_WORK(&led_dat->work, gpio_led_work);

		ret = led_classdev_register(&pdev->dev, &led_dat->cdev);
		if (ret < 0) {
//			gpio_free(led_dat->gpio);
			regulator_put( vmmc2 );
			goto err;
		}
	}

	platform_set_drvdata(pdev, leds_data);

	return 0;

err:
	if (i > 0) {
		for (i = i - 1; i >= 0; i--) {
			led_classdev_unregister(&leds_data[i].cdev);
//			cancel_work_sync(&leds_data[i].work);
//			gpio_free(leds_data[i].gpio);
		}
	}

	kfree(leds_data);

	return ret;
}
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;
}
Esempio n. 28
0
static int __devinit qpnp_leds_probe(struct spmi_device *spmi)
{
	struct qpnp_led_data *led, *led_array;
	struct resource *led_resource;
	struct device_node *node, *temp;
	int rc, i, num_leds = 0, parsed_leds = 0;
	const char *led_label;

	node = spmi->dev.of_node;
	if (node == NULL)
		return -ENODEV;

	temp = NULL;
	while ((temp = of_get_next_child(node, temp)))
		num_leds++;

	if (!num_leds)
		return -ECHILD;

	led_array = devm_kzalloc(&spmi->dev,
		(sizeof(struct qpnp_led_data) * num_leds), GFP_KERNEL);
	if (!led_array) {
		dev_err(&spmi->dev, "Unable to allocate memory\n");
		return -ENOMEM;
	}

	for_each_child_of_node(node, temp) {
		led = &led_array[parsed_leds];
		led->num_leds = num_leds;
		led->spmi_dev = spmi;

		led_resource = spmi_get_resource(spmi, NULL, IORESOURCE_MEM, 0);
		if (!led_resource) {
			dev_err(&spmi->dev, "Unable to get LED base address\n");
			rc = -ENXIO;
			goto fail_id_check;
		}
		led->base = led_resource->start;

		rc = of_property_read_string(temp, "label", &led_label);
		if (rc < 0) {
			dev_err(&led->spmi_dev->dev,
				"Failure reading label, rc = %d\n", rc);
			goto fail_id_check;
		}

		rc = of_property_read_string(temp, "linux,name",
			&led->cdev.name);
		if (rc < 0) {
			dev_err(&led->spmi_dev->dev,
				"Failure reading led name, rc = %d\n", rc);
			goto fail_id_check;
		}

		rc = of_property_read_u32(temp, "qcom,max-current",
			&led->max_current);
		if (rc < 0) {
			dev_err(&led->spmi_dev->dev,
				"Failure reading max_current, rc =  %d\n", rc);
			goto fail_id_check;
		}

		rc = of_property_read_u32(temp, "qcom,id", &led->id);
		if (rc < 0) {
			dev_err(&led->spmi_dev->dev,
				"Failure reading led id, rc =  %d\n", rc);
			goto fail_id_check;
		}

		rc = qpnp_get_common_configs(led, temp);
		if (rc) {
			dev_err(&led->spmi_dev->dev,
				"Failure reading common led configuration," \
				" rc = %d\n", rc);
			goto fail_id_check;
		}

		led->cdev.brightness_set    = qpnp_led_set;
		led->cdev.brightness_get    = qpnp_led_get;

		if (strncmp(led_label, "wled", sizeof("wled")) == 0) {
			rc = qpnp_get_config_wled(led, temp);
			if (rc < 0) {
				dev_err(&led->spmi_dev->dev,
					"Unable to read wled config data\n");
				goto fail_id_check;
			}
		} else if (strncmp(led_label, "flash", sizeof("flash"))
				== 0) {
			rc = qpnp_get_config_flash(led, temp);
			if (rc < 0) {
				dev_err(&led->spmi_dev->dev,
					"Unable to read flash config data\n");
				goto fail_id_check;
			}
		} else if (strncmp(led_label, "rgb", sizeof("rgb")) == 0) {
			rc = qpnp_get_config_rgb(led, temp);
			if (rc < 0) {
				dev_err(&led->spmi_dev->dev,
					"Unable to read rgb config data\n");
				goto fail_id_check;
			}
		} else {
			dev_err(&led->spmi_dev->dev, "No LED matching label\n");
			rc = -EINVAL;
			goto fail_id_check;
		}

		spin_lock_init(&led->lock);

		rc =  qpnp_led_initialize(led);
		if (rc < 0)
			goto fail_id_check;

		rc = qpnp_led_set_max_brightness(led);
		if (rc < 0)
			goto fail_id_check;

		rc = led_classdev_register(&spmi->dev, &led->cdev);
		if (rc) {
			dev_err(&spmi->dev, "unable to register led %d,rc=%d\n",
						 led->id, rc);
			goto fail_id_check;
		}
		/* configure default state */
		if (led->default_on) {
			led->cdev.brightness = led->cdev.max_brightness;
			if (led->turn_off_delay_ms > 0)
				qpnp_led_turn_off(led);
		} else
			led->cdev.brightness = LED_OFF;

		qpnp_led_set(&led->cdev, led->cdev.brightness);

		parsed_leds++;
	}
Esempio n. 29
0
static int __devinit msm_pdm_led_probe(struct platform_device *pdev)
{
	const struct led_info *pdata = pdev->dev.platform_data;
	struct pdm_led_data *led;
	struct resource *res, *ioregion;
	u32 tcxo_pdm_ctl;
	int rc;

	if (!pdata) {
		pr_err("platform data is invalid\n");
		return -EINVAL;
	}

	if (pdev->id > 2) {
		pr_err("pdm id is invalid\n");
		return -EINVAL;
	}

	led = kzalloc(sizeof(struct pdm_led_data), GFP_KERNEL);
	if (!led)
		return -ENOMEM;

	/* Enable runtime PM ops, start in ACTIVE mode */
	rc = pm_runtime_set_active(&pdev->dev);
	if (rc < 0)
		dev_dbg(&pdev->dev, "unable to set runtime pm state\n");
	pm_runtime_enable(&pdev->dev);

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!res) {
		pr_err("get resource failed\n");
		rc = -EINVAL;
		goto err_get_res;
	}

	ioregion = request_mem_region(res->start, resource_size(res),
						pdev->name);
	if (!ioregion) {
		pr_err("request for mem region failed\n");
		rc = -ENOMEM;
		goto err_get_res;
	}

	led->perph_base = ioremap(res->start, resource_size(res));
	if (!led->perph_base) {
		pr_err("ioremap failed\n");
		rc = -ENOMEM;
		goto err_ioremap;
	}

	/* Pulse Density Modulation(PDM) ids start with 0 and
	 * every PDM register takes 4 bytes
	 */
	led->pdm_offset = ((pdev->id) + 1) * 4;

	/* program tcxo_pdm_ctl register to enable pdm*/
	tcxo_pdm_ctl = readl_relaxed(led->perph_base);
	tcxo_pdm_ctl |= (1 << pdev->id);
	writel_relaxed(tcxo_pdm_ctl, led->perph_base);

	/* Start with LED in off state */
	msm_led_brightness_set_percent(led, 0);

	led->cdev.brightness_set = msm_led_brightness_set;
	led->cdev.name = pdata->name ? : "leds-msm-pdm";

	rc = led_classdev_register(&pdev->dev, &led->cdev);
	if (rc) {
		pr_err("led class registration failed\n");
		goto err_led_reg;
	}

#ifdef CONFIG_HAS_EARLYSUSPEND
	led->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN +
						LED_SUSPEND_LEVEL;
	led->early_suspend.suspend = msm_led_pdm_early_suspend;
	register_early_suspend(&led->early_suspend);
#endif

	platform_set_drvdata(pdev, led);
	return 0;

err_led_reg:
	iounmap(led->perph_base);
err_ioremap:
	release_mem_region(res->start, resource_size(res));
err_get_res:
	pm_runtime_set_suspended(&pdev->dev);
	pm_runtime_disable(&pdev->dev);
	kfree(led);
	return rc;
}
static int max77843_rgb_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct max77843_rgb_platform_data *pdata;
	struct max77843_rgb *max77843_rgb;
	struct max77843_dev *max77843_dev = dev_get_drvdata(dev->parent);
	char temp_name[4][40] = {{0,},}, name[40] = {0,}, *p;
	int i, ret;

	pr_info("leds-max77843-rgb: %s\n", __func__);

#ifdef CONFIG_OF
	pdata = max77843_rgb_parse_dt(dev);
	if (unlikely(IS_ERR(pdata)))
		return PTR_ERR(pdata);
#else
	pdata = dev_get_platdata(dev);
#endif

	max77843_rgb = devm_kzalloc(dev, sizeof(struct max77843_rgb), GFP_KERNEL);
	if (unlikely(!max77843_rgb))
		return -ENOMEM;
	pr_info("leds-max77843-rgb: %s 1 \n", __func__);

	max77843_rgb->i2c = max77843_dev->i2c;

	for (i = 0; i < 4; i++) {
		ret = snprintf(name, 30, "%s", pdata->name[i])+1;
		if (1 > ret)
			goto alloc_err_flash;

		p = devm_kzalloc(dev, ret, GFP_KERNEL);
		if (unlikely(!p))
			goto alloc_err_flash;

		strcpy(p, name);
		strcpy(temp_name[i], name);
		max77843_rgb->led[i].name = p;
		max77843_rgb->led[i].brightness_set = max77843_rgb_set;
		max77843_rgb->led[i].brightness_get = max77843_rgb_get;
		max77843_rgb->led[i].max_brightness = LED_MAX_CURRENT;

		ret = led_classdev_register(dev, &max77843_rgb->led[i]);
		if (IS_ERR_VALUE(ret)) {
			dev_err(dev, "unable to register RGB : %d\n", ret);
			goto alloc_err_flash_plus;
		}
		ret = sysfs_create_group(&max77843_rgb->led[i].dev->kobj,
						&common_led_attr_group);
		if (ret) {
			dev_err(dev, "can not register sysfs attribute\n");
			goto register_err_flash;
		}
	}

	led_dev = sec_device_create(max77843_rgb, "led");
	if (IS_ERR(led_dev)) {
		dev_err(dev, "Failed to create device for samsung specific led\n");
		goto register_err_flash;
	}


	ret = sysfs_create_group(&led_dev->kobj, &sec_led_attr_group);
	if (ret < 0) {
		dev_err(dev, "Failed to create sysfs group for samsung specific led\n");
		goto device_create_err;
	}

	platform_set_drvdata(pdev, max77843_rgb);
#if defined(CONFIG_LEDS_USE_ED28) && defined(CONFIG_SEC_FACTORY)
	if( lcdtype == 0 && jig_status == false) {
		max77843_rgb_set_state(&max77843_rgb->led[RED], led_dynamic_current, LED_ALWAYS_ON);
	}
#endif
	lcdtype_color = lcdtype >> 0x10;
	if (lcdtype_color == 51)
		led_color_dynamic_current = 0x5A;

	pr_info("leds-max77843-rgb: %s done\n", __func__);

	return 0;

device_create_err:
	sec_device_destroy(led_dev->devt);
register_err_flash:
	led_classdev_unregister(&max77843_rgb->led[i]);
alloc_err_flash_plus:
	devm_kfree(dev, temp_name[i]);
alloc_err_flash:
	while (i--) {
		led_classdev_unregister(&max77843_rgb->led[i]);
		devm_kfree(dev, temp_name[i]);
	}
	devm_kfree(dev, max77843_rgb);
	return -ENOMEM;
}