/** * 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; }
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; }
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; }
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; }
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; }
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; };
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; }
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; }
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; }
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; }
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; };
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; }
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; }
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; }
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; }
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; }
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; }
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; }
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++; }
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; }