drivers/gpu/drm/nouveau/nouveau_backlight.c

   1 /*
   2  * Copyright (C) 2009 Red Hat <mjg@redhat.com>
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining
   5  * a copy of this software and associated documentation files (the
   6  * "Software"), to deal in the Software without restriction, including
   7  * without limitation the rights to use, copy, modify, merge, publish,
   8  * distribute, sublicense, and/or sell copies of the Software, and to
   9  * permit persons to whom the Software is furnished to do so, subject to
  10  * the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the
  13  * next paragraph) shall be included in all copies or substantial
  14  * portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  17  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  19  * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  20  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  21  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  22  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  *
  24  */
  25
  26 /*
  27  * Authors:
  28  *  Matthew Garrett <mjg@redhat.com>
  29  *
  30  * Register locations derived from NVClock by Roderick Colenbrander
  31  */
  32
  33 #include <linux/apple-gmux.h>
  34 #include <linux/backlight.h>
  35 #include <linux/idr.h>
  36
  37 #include "nouveau_drv.h"
  38 #include "nouveau_reg.h"
  39 #include "nouveau_encoder.h"
  40
  41 static struct ida bl_ida;
  42 #define BL_NAME_SIZE 15 // 12 for name + 2 for digits + 1 for '\0'
  43
  44 struct backlight_connector {
  45         struct list_head head;
  46         int id;
  47 };
  48
  49 static bool
  50 nouveau_get_backlight_name(char backlight_name[BL_NAME_SIZE], struct backlight_connector
  51                 *connector)
  52 {
  53         const int nb = ida_simple_get(&bl_ida, 0, 0, GFP_KERNEL);
  54         if (nb < 0 || nb >= 100)
  55                 return false;
  56         if (nb > 0)
  57                 snprintf(backlight_name, BL_NAME_SIZE, "nv_backlight%d", nb);
  58         else
  59                 snprintf(backlight_name, BL_NAME_SIZE, "nv_backlight");
  60         connector->id = nb;
  61         return true;
  62 }
  63
  64 static int
  65 nv40_get_intensity(struct backlight_device *bd)
  66 {
  67         struct nouveau_drm *drm = bl_get_data(bd);
  68         struct nvif_object *device = &drm->client.device.object;
  69         int val = (nvif_rd32(device, NV40_PMC_BACKLIGHT) &
  70                                    NV40_PMC_BACKLIGHT_MASK) >> 16;
  71
  72         return val;
  73 }
  74
  75 static int
  76 nv40_set_intensity(struct backlight_device *bd)
  77 {
  78         struct nouveau_drm *drm = bl_get_data(bd);
  79         struct nvif_object *device = &drm->client.device.object;
  80         int val = bd->props.brightness;
  81         int reg = nvif_rd32(device, NV40_PMC_BACKLIGHT);
  82
  83         nvif_wr32(device, NV40_PMC_BACKLIGHT,
  84                  (val << 16) | (reg & ~NV40_PMC_BACKLIGHT_MASK));
  85
  86         return 0;
  87 }
  88
  89 static const struct backlight_ops nv40_bl_ops = {
  90         .options = BL_CORE_SUSPENDRESUME,
  91         .get_brightness = nv40_get_intensity,
  92         .update_status = nv40_set_intensity,
  93 };
  94
  95 static int
  96 nv40_backlight_init(struct drm_connector *connector)
  97 {
  98         struct nouveau_drm *drm = nouveau_drm(connector->dev);
  99         struct nvif_object *device = &drm->client.device.object;
 100         struct backlight_properties props;
 101         struct backlight_device *bd;
 102         struct backlight_connector bl_connector;
 103         char backlight_name[BL_NAME_SIZE];
 104
 105         if (!(nvif_rd32(device, NV40_PMC_BACKLIGHT) & NV40_PMC_BACKLIGHT_MASK))
 106                 return 0;
 107
 108         memset(&props, 0, sizeof(struct backlight_properties));
 109         props.type = BACKLIGHT_RAW;
 110         props.max_brightness = 31;
 111         if (!nouveau_get_backlight_name(backlight_name, &bl_connector)) {
 112                 NV_ERROR(drm, "Failed to retrieve a unique name for the backlight interface\n");
 113                 return 0;
 114         }
 115         bd = backlight_device_register(backlight_name , connector->kdev, drm,
 116                                        &nv40_bl_ops, &props);
 117
 118         if (IS_ERR(bd)) {
 119                 if (bl_connector.id >= 0)
 120                         ida_simple_remove(&bl_ida, bl_connector.id);
 121                 return PTR_ERR(bd);
 122         }
 123         list_add(&bl_connector.head, &drm->bl_connectors);
 124         drm->backlight = bd;
 125         bd->props.brightness = nv40_get_intensity(bd);
 126         backlight_update_status(bd);
 127
 128         return 0;
 129 }
 130
 131 static int
 132 nv50_get_intensity(struct backlight_device *bd)
 133 {
 134         struct nouveau_encoder *nv_encoder = bl_get_data(bd);
 135         struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
 136         struct nvif_object *device = &drm->client.device.object;
 137         int or = ffs(nv_encoder->dcb->or) - 1;
 138         u32 div = 1025;
 139         u32 val;
 140
 141         val  = nvif_rd32(device, NV50_PDISP_SOR_PWM_CTL(or));
 142         val &= NV50_PDISP_SOR_PWM_CTL_VAL;
 143         return ((val * 100) + (div / 2)) / div;
 144 }
 145
 146 static int
 147 nv50_set_intensity(struct backlight_device *bd)
 148 {
 149         struct nouveau_encoder *nv_encoder = bl_get_data(bd);
 150         struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
 151         struct nvif_object *device = &drm->client.device.object;
 152         int or = ffs(nv_encoder->dcb->or) - 1;
 153         u32 div = 1025;
 154         u32 val = (bd->props.brightness * div) / 100;
 155
 156         nvif_wr32(device, NV50_PDISP_SOR_PWM_CTL(or),
 157                         NV50_PDISP_SOR_PWM_CTL_NEW | val);
 158         return 0;
 159 }
 160
 161 static const struct backlight_ops nv50_bl_ops = {
 162         .options = BL_CORE_SUSPENDRESUME,
 163         .get_brightness = nv50_get_intensity,
 164         .update_status = nv50_set_intensity,
 165 };
 166
 167 static int
 168 nva3_get_intensity(struct backlight_device *bd)
 169 {
 170         struct nouveau_encoder *nv_encoder = bl_get_data(bd);
 171         struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
 172         struct nvif_object *device = &drm->client.device.object;
 173         int or = ffs(nv_encoder->dcb->or) - 1;
 174         u32 div, val;
 175
 176         div  = nvif_rd32(device, NV50_PDISP_SOR_PWM_DIV(or));
 177         val  = nvif_rd32(device, NV50_PDISP_SOR_PWM_CTL(or));
 178         val &= NVA3_PDISP_SOR_PWM_CTL_VAL;
 179         if (div && div >= val)
 180                 return ((val * 100) + (div / 2)) / div;
 181
 182         return 100;
 183 }
 184
 185 static int
 186 nva3_set_intensity(struct backlight_device *bd)
 187 {
 188         struct nouveau_encoder *nv_encoder = bl_get_data(bd);
 189         struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
 190         struct nvif_object *device = &drm->client.device.object;
 191         int or = ffs(nv_encoder->dcb->or) - 1;
 192         u32 div, val;
 193
 194         div = nvif_rd32(device, NV50_PDISP_SOR_PWM_DIV(or));
 195         val = (bd->props.brightness * div) / 100;
 196         if (div) {
 197                 nvif_wr32(device, NV50_PDISP_SOR_PWM_CTL(or), val |
 198                                 NV50_PDISP_SOR_PWM_CTL_NEW |
 199                                 NVA3_PDISP_SOR_PWM_CTL_UNK);
 200                 return 0;
 201         }
 202
 203         return -EINVAL;
 204 }
 205
 206 static const struct backlight_ops nva3_bl_ops = {
 207         .options = BL_CORE_SUSPENDRESUME,
 208         .get_brightness = nva3_get_intensity,
 209         .update_status = nva3_set_intensity,
 210 };
 211
 212 static int
 213 nv50_backlight_init(struct drm_connector *connector)
 214 {
 215         struct nouveau_drm *drm = nouveau_drm(connector->dev);
 216         struct nvif_object *device = &drm->client.device.object;
 217         struct nouveau_encoder *nv_encoder;
 218         struct backlight_properties props;
 219         struct backlight_device *bd;
 220         const struct backlight_ops *ops;
 221         struct backlight_connector bl_connector;
 222         char backlight_name[BL_NAME_SIZE];
 223
 224         nv_encoder = find_encoder(connector, DCB_OUTPUT_LVDS);
 225         if (!nv_encoder) {
 226                 nv_encoder = find_encoder(connector, DCB_OUTPUT_DP);
 227                 if (!nv_encoder)
 228                         return -ENODEV;
 229         }
 230
 231         if (!nvif_rd32(device, NV50_PDISP_SOR_PWM_CTL(ffs(nv_encoder->dcb->or) - 1)))
 232                 return 0;
 233
 234         if (drm->client.device.info.chipset <= 0xa0 ||
 235             drm->client.device.info.chipset == 0xaa ||
 236             drm->client.device.info.chipset == 0xac)
 237                 ops = &nv50_bl_ops;
 238         else
 239                 ops = &nva3_bl_ops;
 240
 241         memset(&props, 0, sizeof(struct backlight_properties));
 242         props.type = BACKLIGHT_RAW;
 243         props.max_brightness = 100;
 244         if (!nouveau_get_backlight_name(backlight_name, &bl_connector)) {
 245                 NV_ERROR(drm, "Failed to retrieve a unique name for the backlight interface\n");
 246                 return 0;
 247         }
 248         bd = backlight_device_register(backlight_name , connector->kdev,
 249                                        nv_encoder, ops, &props);
 250
 251         if (IS_ERR(bd)) {
 252                 if (bl_connector.id >= 0)
 253                         ida_simple_remove(&bl_ida, bl_connector.id);
 254                 return PTR_ERR(bd);
 255         }
 256
 257         list_add(&bl_connector.head, &drm->bl_connectors);
 258         drm->backlight = bd;
 259         bd->props.brightness = bd->ops->get_brightness(bd);
 260         backlight_update_status(bd);
 261         return 0;
 262 }
 263
 264 int
 265 nouveau_backlight_init(struct drm_device *dev)
 266 {
 267         struct nouveau_drm *drm = nouveau_drm(dev);
 268         struct nvif_device *device = &drm->client.device;
 269         struct drm_connector *connector;
 270         struct drm_connector_list_iter conn_iter;
 271
 272         INIT_LIST_HEAD(&drm->bl_connectors);
 273
 274         if (apple_gmux_present()) {
 275                 NV_INFO(drm, "Apple GMUX detected: not registering Nouveau backlight interface\n");
 276                 return 0;
 277         }
 278
 279         drm_connector_list_iter_begin(dev, &conn_iter);
 280         drm_for_each_connector_iter(connector, &conn_iter) {
 281                 if (connector->connector_type != DRM_MODE_CONNECTOR_LVDS &&
 282                     connector->connector_type != DRM_MODE_CONNECTOR_eDP)
 283                         continue;
 284
 285                 switch (device->info.family) {
 286                 case NV_DEVICE_INFO_V0_CURIE:
 287                         return nv40_backlight_init(connector);
 288                 case NV_DEVICE_INFO_V0_TESLA:
 289                 case NV_DEVICE_INFO_V0_FERMI:
 290                 case NV_DEVICE_INFO_V0_KEPLER:
 291                 case NV_DEVICE_INFO_V0_MAXWELL:
 292                         return nv50_backlight_init(connector);
 293                 default:
 294                         break;
 295                 }
 296         }
 297         drm_connector_list_iter_end(&conn_iter);
 298
 299         return 0;
 300 }
 301
 302 void
 303 nouveau_backlight_exit(struct drm_device *dev)
 304 {
 305         struct nouveau_drm *drm = nouveau_drm(dev);
 306         struct backlight_connector *connector;
 307
 308         list_for_each_entry(connector, &drm->bl_connectors, head) {
 309                 if (connector->id >= 0)
 310                         ida_simple_remove(&bl_ida, connector->id);
 311         }
 312
 313         if (drm->backlight) {
 314                 backlight_device_unregister(drm->backlight);
 315                 drm->backlight = NULL;
 316         }
 317 }
 318
 319 void
 320 nouveau_backlight_ctor(void)
 321 {
 322         ida_init(&bl_ida);
 323 }
 324
 325 void
 326 nouveau_backlight_dtor(void)
 327 {
 328         ida_destroy(&bl_ida);
 329 }