drivers/video/backlight/pcf50633-backlight.c

   1 /*
   2  *  Copyright (C) 2009-2010, Lars-Peter Clausen <lars@metafoo.de>
   3  *      PCF50633 backlight device driver
   4  *
   5  *  This program is free software; you can redistribute  it and/or modify it
   6  *  under  the terms of  the GNU General  Public License as published by the
   7  *  Free Software Foundation;  either version 2 of the  License, or (at your
   8  *  option) any later version.
   9  *
  10  *  You should have received a copy of the  GNU General Public License along
  11  *  with this program; if not, write  to the Free Software Foundation, Inc.,
  12  *  675 Mass Ave, Cambridge, MA 02139, USA.
  13  *
  14  */
  15
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/slab.h>
  19 #include <linux/platform_device.h>
  20
  21 #include <linux/backlight.h>
  22 #include <linux/fb.h>
  23
  24 #include <linux/mfd/pcf50633/core.h>
  25 #include <linux/mfd/pcf50633/backlight.h>
  26
  27 struct pcf50633_bl {
  28         struct pcf50633 *pcf;
  29         struct backlight_device *bl;
  30
  31         unsigned int brightness;
  32         unsigned int brightness_limit;
  33 };
  34
  35 /*
  36  * pcf50633_bl_set_brightness_limit
  37  *
  38  * Update the brightness limit for the pc50633 backlight. The actual brightness
  39  * will not go above the limit. This is useful to limit power drain for example
  40  * on low battery.
  41  *
  42  * @dev: Pointer to a pcf50633 device
  43  * @limit: The brightness limit. Valid values are 0-63
  44  */
  45 int pcf50633_bl_set_brightness_limit(struct pcf50633 *pcf, unsigned int limit)
  46 {
  47         struct pcf50633_bl *pcf_bl = platform_get_drvdata(pcf->bl_pdev);
  48
  49         if (!pcf_bl)
  50                 return -ENODEV;
  51
  52         pcf_bl->brightness_limit = limit & 0x3f;
  53         backlight_update_status(pcf_bl->bl);
  54
  55     return 0;
  56 }
  57
  58 static int pcf50633_bl_update_status(struct backlight_device *bl)
  59 {
  60         struct pcf50633_bl *pcf_bl = bl_get_data(bl);
  61         unsigned int new_brightness;
  62
  63
  64         if (bl->props.state & (BL_CORE_SUSPENDED | BL_CORE_FBBLANK) ||
  65                 bl->props.power != FB_BLANK_UNBLANK)
  66                 new_brightness = 0;
  67         else if (bl->props.brightness < pcf_bl->brightness_limit)
  68                 new_brightness = bl->props.brightness;
  69         else
  70                 new_brightness = pcf_bl->brightness_limit;
  71
  72
  73         if (pcf_bl->brightness == new_brightness)
  74                 return 0;
  75
  76         if (new_brightness) {
  77                 pcf50633_reg_write(pcf_bl->pcf, PCF50633_REG_LEDOUT,
  78                                         new_brightness);
  79                 if (!pcf_bl->brightness)
  80                         pcf50633_reg_write(pcf_bl->pcf, PCF50633_REG_LEDENA, 1);
  81         } else {
  82                 pcf50633_reg_write(pcf_bl->pcf, PCF50633_REG_LEDENA, 0);
  83         }
  84
  85         pcf_bl->brightness = new_brightness;
  86
  87         return 0;
  88 }
  89
  90 static int pcf50633_bl_get_brightness(struct backlight_device *bl)
  91 {
  92         struct pcf50633_bl *pcf_bl = bl_get_data(bl);
  93         return pcf_bl->brightness;
  94 }
  95
  96 static const struct backlight_ops pcf50633_bl_ops = {
  97         .get_brightness = pcf50633_bl_get_brightness,
  98         .update_status  = pcf50633_bl_update_status,
  99         .options        = BL_CORE_SUSPENDRESUME,
 100 };
 101
 102 static int __devinit pcf50633_bl_probe(struct platform_device *pdev)
 103 {
 104         int ret;
 105         struct pcf50633_bl *pcf_bl;
 106         struct device *parent = pdev->dev.parent;
 107         struct pcf50633_platform_data *pcf50633_data = parent->platform_data;
 108         struct pcf50633_bl_platform_data *pdata = pcf50633_data->backlight_data;
 109         struct backlight_properties bl_props;
 110
 111         pcf_bl = kzalloc(sizeof(*pcf_bl), GFP_KERNEL);
 112         if (!pcf_bl)
 113                 return -ENOMEM;
 114
 115         bl_props.type = BACKLIGHT_RAW;
 116         bl_props.max_brightness = 0x3f;
 117         bl_props.power = FB_BLANK_UNBLANK;
 118
 119         if (pdata) {
 120                 bl_props.brightness = pdata->default_brightness;
 121                 pcf_bl->brightness_limit = pdata->default_brightness_limit;
 122         } else {
 123                 bl_props.brightness = 0x3f;
 124                 pcf_bl->brightness_limit = 0x3f;
 125         }
 126
 127         pcf_bl->pcf = dev_to_pcf50633(pdev->dev.parent);
 128
 129         pcf_bl->bl = backlight_device_register(pdev->name, &pdev->dev, pcf_bl,
 130                                                 &pcf50633_bl_ops, &bl_props);
 131
 132         if (IS_ERR(pcf_bl->bl)) {
 133                 ret = PTR_ERR(pcf_bl->bl);
 134                 goto err_free;
 135         }
 136
 137         platform_set_drvdata(pdev, pcf_bl);
 138
 139         pcf50633_reg_write(pcf_bl->pcf, PCF50633_REG_LEDDIM, pdata->ramp_time);
 140
 141         /* Should be different from bl_props.brightness, so we do not exit
 142          * update_status early the first time it's called */
 143         pcf_bl->brightness = pcf_bl->bl->props.brightness + 1;
 144
 145         backlight_update_status(pcf_bl->bl);
 146
 147         return 0;
 148
 149 err_free:
 150         kfree(pcf_bl);
 151
 152         return ret;
 153 }
 154
 155 static int __devexit pcf50633_bl_remove(struct platform_device *pdev)
 156 {
 157         struct pcf50633_bl *pcf_bl = platform_get_drvdata(pdev);
 158
 159         backlight_device_unregister(pcf_bl->bl);
 160
 161         platform_set_drvdata(pdev, NULL);
 162
 163         kfree(pcf_bl);
 164
 165         return 0;
 166 }
 167
 168 static struct platform_driver pcf50633_bl_driver = {
 169         .probe =        pcf50633_bl_probe,
 170         .remove =       __devexit_p(pcf50633_bl_remove),
 171         .driver = {
 172                 .name = "pcf50633-backlight",
 173         },
 174 };
 175
 176 static int __init pcf50633_bl_init(void)
 177 {
 178         return platform_driver_register(&pcf50633_bl_driver);
 179 }
 180 module_init(pcf50633_bl_init);
 181
 182 static void __exit pcf50633_bl_exit(void)
 183 {
 184         platform_driver_unregister(&pcf50633_bl_driver);
 185 }
 186 module_exit(pcf50633_bl_exit);
 187
 188 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
 189 MODULE_DESCRIPTION("PCF50633 backlight driver");
 190 MODULE_LICENSE("GPL");
 191 MODULE_ALIAS("platform:pcf50633-backlight");