/*++ linux/drivers/video/backlight/pwm_bl.c Copyright (c) 2013 WonderMedia Technologies, Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . WonderMedia Technologies, Inc. 10F, 529, Chung-Cheng Road, Hsin-Tien, Taipei 231, R.O.C. --*/ #include #include #include #include #include #include #include #include #include #include #include struct pwm_bl_data { struct pwm_device *pwm; struct device *dev; unsigned int invert; unsigned int period; unsigned int lth_ns; unsigned int hth_ns; int (*notify)(struct device *, int brightness); void (*notify_after)(struct device *, int brightness); int (*check_fb)(struct device *, struct fb_info *); }; static inline void __pwm0_gpio_setup(void) { /* select pwm function */ REG8_VAL(GPIO_CTRL_GP20_PWM0_BYTE_ADDR) &= ~0x1; /* pwm0 output enable */ REG8_VAL(GPIO_OD_GP20_PWM0_BYTE_ADDR) &= ~0x01; /* share pin */ REG32_VAL(PIN_SHARING_SEL_4BYTE_ADDR) &= ~0x1000; } static int pwm_backlight_update_status(struct backlight_device *bl) { struct pwm_bl_data *pb = dev_get_drvdata(&bl->dev); int brightness = bl->props.brightness; int max = bl->props.max_brightness; // if (bl->props.power != FB_BLANK_UNBLANK) // brightness = 0; // // if (bl->props.fb_blank != FB_BLANK_UNBLANK) // brightness = 0; if (pb->notify) brightness = pb->notify(pb->dev, brightness); if (brightness == 0) { if (pb->invert) { pwm_config(pb->pwm, pb->period, pb->period); } else { pwm_config(pb->pwm, 0, pb->period); pwm_disable(pb->pwm); } } else { brightness = pb->lth_ns + (brightness * (pb->period - pb->lth_ns - pb->hth_ns) / max); if (pb->invert) brightness = pb->period - brightness; pwm_config(pb->pwm, brightness, pb->period); pwm_enable(pb->pwm); } if (pb->notify_after) pb->notify_after(pb->dev, brightness); return 0; } static int pwm_backlight_get_brightness(struct backlight_device *bl) { return bl->props.brightness; } static int pwm_backlight_check_fb(struct backlight_device *bl, struct fb_info *info) { struct pwm_bl_data *pb = dev_get_drvdata(&bl->dev); return !pb->check_fb || pb->check_fb(pb->dev, info); } static const struct backlight_ops pwm_backlight_ops = { .update_status = pwm_backlight_update_status, .get_brightness = pwm_backlight_get_brightness, .check_fb = pwm_backlight_check_fb, }; static int pwm_backlight_probe(struct platform_device *pdev) { struct backlight_properties props; struct platform_pwm_backlight_data *data = pdev->dev.platform_data; struct backlight_device *bl; struct pwm_bl_data *pb; int ret; if (!data) { dev_err(&pdev->dev, "failed to find platform data\n"); return -EINVAL; } if (data->init) { ret = data->init(&pdev->dev); if (ret < 0) return ret; } pb = devm_kzalloc(&pdev->dev, sizeof(*pb), GFP_KERNEL); if (!pb) { dev_err(&pdev->dev, "no memory for state\n"); ret = -ENOMEM; goto err_alloc; } __pwm0_gpio_setup(); pb->invert = data->invert; pb->period = data->pwm_period_ns; pb->notify = data->notify; pb->notify_after = data->notify_after; pb->check_fb = data->check_fb; pb->lth_ns = data->lth_brightness * (data->pwm_period_ns / data->max_brightness); pb->hth_ns = (data->max_brightness - data->hth_brightness) * (data->pwm_period_ns / data->max_brightness); pb->dev = &pdev->dev; pb->pwm = pwm_request(data->pwm_id, "backlight"); if (IS_ERR(pb->pwm)) { dev_err(&pdev->dev, "unable to request PWM for backlight\n"); ret = PTR_ERR(pb->pwm); goto err_alloc; } else dev_dbg(&pdev->dev, "got pwm for backlight\n"); memset(&props, 0, sizeof(struct backlight_properties)); props.type = BACKLIGHT_RAW; props.max_brightness = data->max_brightness; bl = backlight_device_register(dev_name(&pdev->dev), &pdev->dev, pb, &pwm_backlight_ops, &props); if (IS_ERR(bl)) { dev_err(&pdev->dev, "failed to register backlight\n"); ret = PTR_ERR(bl); goto err_bl; } bl->props.brightness = data->dft_brightness; //backlight_update_status(bl); platform_set_drvdata(pdev, bl); return 0; err_bl: pwm_free(pb->pwm); err_alloc: if (data->exit) data->exit(&pdev->dev); return ret; } static int pwm_backlight_remove(struct platform_device *pdev) { struct platform_pwm_backlight_data *data = pdev->dev.platform_data; struct backlight_device *bl = platform_get_drvdata(pdev); struct pwm_bl_data *pb = dev_get_drvdata(&bl->dev); backlight_device_unregister(bl); pwm_config(pb->pwm, 0, pb->period); pwm_disable(pb->pwm); pwm_free(pb->pwm); if (data->exit) data->exit(&pdev->dev); return 0; } #ifdef CONFIG_PM static int pwm_backlight_suspend(struct device *dev) { struct backlight_device *bl = dev_get_drvdata(dev); struct pwm_bl_data *pb = dev_get_drvdata(&bl->dev); if (pb->notify) pb->notify(pb->dev, 0); if (pb->invert) { pwm_config(pb->pwm, pb->period, pb->period); } else { pwm_config(pb->pwm, 0, pb->period); pwm_disable(pb->pwm); } if (pb->notify_after) pb->notify_after(pb->dev, 0); return 0; } static int pwm_backlight_resume(struct device *dev) { //struct backlight_device *bl = dev_get_drvdata(dev); //backlight_update_status(bl); __pwm0_gpio_setup(); return 0; } static SIMPLE_DEV_PM_OPS(pwm_backlight_pm_ops, pwm_backlight_suspend, pwm_backlight_resume); #endif static void pwm_backlight_shutdown(struct platform_device *pdev) { pwm_backlight_suspend(&pdev->dev); } static struct platform_driver pwm_backlight_driver = { .driver = { .name = "pwm-backlight", .owner = THIS_MODULE, #ifdef CONFIG_PM .pm = &pwm_backlight_pm_ops, #endif }, .probe = pwm_backlight_probe, .remove = pwm_backlight_remove, .shutdown = pwm_backlight_shutdown, }; module_platform_driver(pwm_backlight_driver); MODULE_DESCRIPTION("PWM based Backlight Driver"); MODULE_LICENSE("GPL"); MODULE_ALIAS("platform:pwm-backlight");