drivers/staging/mrst/drv/psb_bl.c

   1 /*
   2  *  psb backlight using HAL
   3  *
   4  * Copyright (c) 2009, Intel Corporation.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms and conditions of the GNU General Public License,
   8  * version 2, as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along with
  16  * this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Authors: Eric Knopp
  20  *
  21  */
  22
  23 #include <linux/backlight.h>
  24 #include <linux/version.h>
  25 #include <asm/intel_scu_ipc.h>
  26 #include "psb_drv.h"
  27 #include "psb_intel_reg.h"
  28 #include "psb_intel_drv.h"
  29 #include "psb_powermgmt.h"
  30 #include "mdfld_dsi_dbi.h"
  31 #include "tc35876x-dsi-lvds.h"
  32
  33 #define MRST_BLC_MAX_PWM_REG_FREQ           0xFFFF
  34 #define BLC_PWM_PRECISION_FACTOR 100    /* 10000000 */
  35 #define BLC_PWM_FREQ_CALC_CONSTANT 32
  36 #define MHz 1000000
  37 #define BRIGHTNESS_MIN_LEVEL 1
  38 #define BRIGHTNESS_MAX_LEVEL 100
  39 #define BRIGHTNESS_MASK 0xFF
  40 #define BLC_POLARITY_NORMAL 0
  41 #define BLC_POLARITY_INVERSE 1
  42 #define BLC_ADJUSTMENT_MAX 100
  43
  44 #define PSB_BLC_PWM_PRECISION_FACTOR    10
  45 #define PSB_BLC_MAX_PWM_REG_FREQ        0xFFFE
  46 #define PSB_BLC_MIN_PWM_REG_FREQ        0x2
  47
  48 #define PSB_BACKLIGHT_PWM_POLARITY_BIT_CLEAR (0xFFFE)
  49 #define PSB_BACKLIGHT_PWM_CTL_SHIFT     (16)
  50
  51 static struct backlight_device *psb_backlight_device;
  52
  53 int psb_set_brightness(struct backlight_device *bd)
  54 {
  55         struct drm_device *dev =
  56             (struct drm_device *)bl_get_data(psb_backlight_device);
  57         struct drm_psb_private *dev_priv =
  58             (struct drm_psb_private *)dev->dev_private;
  59         int level = bd->props.brightness;
  60
  61         DRM_DEBUG_DRIVER("backlight level set to %d\n", level);
  62
  63         /* Perform value bounds checking */
  64         if (level < BRIGHTNESS_MIN_LEVEL)
  65                 level = BRIGHTNESS_MIN_LEVEL;
  66
  67         if (ospm_power_using_hw_begin(OSPM_DISPLAY_ISLAND, false)) {
  68                 u32 adjusted_level = 0;
  69
  70                 /*
  71                  * Adjust the backlight level with the percent in
  72                  * dev_priv->blc_adj2
  73                  */
  74                 adjusted_level = level * dev_priv->blc_adj2;
  75                 adjusted_level = adjusted_level / BLC_ADJUSTMENT_MAX;
  76                 dev_priv->brightness_adjusted = adjusted_level;
  77
  78 #ifndef CONFIG_MDFLD_DSI_DPU
  79                 if((!(dev_priv->dsr_fb_update & MDFLD_DSR_MIPI_CONTROL)) &&
  80                         (dev_priv->dbi_panel_on || dev_priv->dbi_panel_on2)){
  81                         mdfld_dsi_dbi_exit_dsr(dev,MDFLD_DSR_MIPI_CONTROL, 0, 0);
  82                         PSB_DEBUG_ENTRY("Out of DSR before set brightness to %d.\n",
  83                                         dev_priv->brightness_adjusted);
  84                 }
  85 #endif
  86                 {
  87                         if (dev_priv->dbi_panel_on || dev_priv->dpi_panel_on)
  88                                 mdfld_dsi_brightness_control(dev, 0,
  89                                                              dev_priv->brightness_adjusted);
  90                 }
  91
  92                 if ((dev_priv->dbi_panel_on2) || (dev_priv->dpi_panel_on2))
  93                         mdfld_dsi_brightness_control(dev, 2, dev_priv->brightness_adjusted);
  94                 ospm_power_using_hw_end(OSPM_DISPLAY_ISLAND);
  95         }
  96
  97         /* cache the brightness for later use */
  98         dev_priv->brightness = level;
  99         return 0;
 100 }
 101
 102 int psb_get_brightness(struct backlight_device *bd)
 103 {
 104         struct drm_device *dev =
 105             (struct drm_device *)bl_get_data(psb_backlight_device);
 106         struct drm_psb_private *dev_priv =
 107             (struct drm_psb_private *)dev->dev_private;
 108
 109         DRM_DEBUG_DRIVER("brightness = 0x%x \n", dev_priv->brightness);
 110
 111         /* return locally cached var instead of HW read (due to DPST etc.) */
 112         return dev_priv->brightness;
 113 }
 114
 115 #ifdef CONFIG_BACKLIGHT_CLASS_DEVICE
 116 static struct backlight_ops psb_ops = {
 117         .get_brightness = psb_get_brightness,
 118         .update_status  = psb_set_brightness,
 119 };
 120
 121 static int device_backlight_init(struct drm_device *dev)
 122 {
 123         struct drm_psb_private *dev_priv = (struct drm_psb_private *)
 124                 dev->dev_private;
 125
 126         dev_priv->blc_adj1 = BLC_ADJUSTMENT_MAX;
 127         dev_priv->blc_adj2 = BLC_ADJUSTMENT_MAX;
 128
 129         return 0;
 130 }
 131 #endif
 132
 133 int psb_backlight_init(struct drm_device *dev)
 134 {
 135 #ifdef CONFIG_BACKLIGHT_CLASS_DEVICE
 136         struct drm_psb_private *dev_priv = (struct drm_psb_private *) dev->dev_private;
 137         struct backlight_properties props;
 138         uint8_t data = 0;
 139         int ret = 0;
 140
 141         dev_priv->b_pmic_backlight = false;
 142
 143         memset(&props, 0, sizeof(struct backlight_properties));
 144         props.max_brightness = BRIGHTNESS_MAX_LEVEL;
 145         props.type = BACKLIGHT_PLATFORM;
 146         psb_backlight_device = backlight_device_register("psb-bl", NULL, (void *)dev, &psb_ops, &props);
 147
 148         if (IS_ERR(psb_backlight_device))
 149                 return PTR_ERR(psb_backlight_device);
 150
 151         if ((ret = device_backlight_init(dev)) != 0)
 152                 return ret;
 153
 154         psb_backlight_device->props.brightness = BRIGHTNESS_MAX_LEVEL;
 155         psb_backlight_device->props.max_brightness = BRIGHTNESS_MAX_LEVEL;
 156         if (dev_priv->b_pmic_backlight) {
 157                 intel_scu_ipc_ioread8(0x28, &data);
 158                 dev_priv->saveBKLTCNT = data;
 159                 intel_scu_ipc_ioread8(0x29, &data);
 160                 dev_priv->saveBKLTREQ = data;
 161                 intel_scu_ipc_ioread8(0x2A, &data);
 162                 dev_priv->saveBKLTBRTL = data;
 163         }
 164         backlight_update_status(psb_backlight_device);
 165 #endif
 166         return 0;
 167 }
 168
 169 void psb_backlight_exit(void)
 170 {
 171 #ifdef CONFIG_BACKLIGHT_CLASS_DEVICE
 172         psb_backlight_device->props.brightness = 0;
 173         backlight_update_status(psb_backlight_device);
 174         backlight_device_unregister(psb_backlight_device);
 175 #endif
 176         return;
 177 }
 178
 179 struct backlight_device * psb_get_backlight_device(void)
 180 {
 181 #ifdef CONFIG_BACKLIGHT_CLASS_DEVICE
 182         return psb_backlight_device;
 183 #endif
 184         return NULL;
 185 }