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 #include "nouveau_connector.h"
  41
  42 static struct ida bl_ida;
  43 #define BL_NAME_SIZE 15 // 12 for name + 2 for digits + 1 for '\0'
  44
  45 static bool
  46 nouveau_get_backlight_name(char backlight_name[BL_NAME_SIZE],
  47                            struct nouveau_backlight *bl)
  48 {
  49         const int nb = ida_alloc_max(&bl_ida, 99, GFP_KERNEL);
  50
  51         if (nb < 0)
  52                 return false;
  53         if (nb > 0)
  54                 snprintf(backlight_name, BL_NAME_SIZE, "nv_backlight%d", nb);
  55         else
  56                 snprintf(backlight_name, BL_NAME_SIZE, "nv_backlight");
  57         bl->id = nb;
  58         return true;
  59 }
  60
  61 static int
  62 nv40_get_intensity(struct backlight_device *bd)
  63 {
  64         struct nouveau_encoder *nv_encoder = bl_get_data(bd);
  65         struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
  66         struct nvif_object *device = &drm->client.device.object;
  67         int val = (nvif_rd32(device, NV40_PMC_BACKLIGHT) &
  68                    NV40_PMC_BACKLIGHT_MASK) >> 16;
  69
  70         return val;
  71 }
  72
  73 static int
  74 nv40_set_intensity(struct backlight_device *bd)
  75 {
  76         struct nouveau_encoder *nv_encoder = bl_get_data(bd);
  77         struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
  78         struct nvif_object *device = &drm->client.device.object;
  79         int val = bd->props.brightness;
  80         int reg = nvif_rd32(device, NV40_PMC_BACKLIGHT);
  81
  82         nvif_wr32(device, NV40_PMC_BACKLIGHT,
  83                   (val << 16) | (reg & ~NV40_PMC_BACKLIGHT_MASK));
  84
  85         return 0;
  86 }
  87
  88 static const struct backlight_ops nv40_bl_ops = {
  89         .options = BL_CORE_SUSPENDRESUME,
  90         .get_brightness = nv40_get_intensity,
  91         .update_status = nv40_set_intensity,
  92 };
  93
  94 static int
  95 nv40_backlight_init(struct nouveau_encoder *encoder,
  96                     struct backlight_properties *props,
  97                     const struct backlight_ops **ops)
  98 {
  99         struct nouveau_drm *drm = nouveau_drm(encoder->base.base.dev);
 100         struct nvif_object *device = &drm->client.device.object;
 101
 102         if (!(nvif_rd32(device, NV40_PMC_BACKLIGHT) & NV40_PMC_BACKLIGHT_MASK))
 103                 return -ENODEV;
 104
 105         props->max_brightness = 31;
 106         *ops = &nv40_bl_ops;
 107         return 0;
 108 }
 109
 110 static int
 111 nv50_get_intensity(struct backlight_device *bd)
 112 {
 113         struct nouveau_encoder *nv_encoder = bl_get_data(bd);
 114         struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
 115         struct nvif_object *device = &drm->client.device.object;
 116         int or = ffs(nv_encoder->dcb->or) - 1;
 117         u32 div = 1025;
 118         u32 val;
 119
 120         val  = nvif_rd32(device, NV50_PDISP_SOR_PWM_CTL(or));
 121         val &= NV50_PDISP_SOR_PWM_CTL_VAL;
 122         return ((val * 100) + (div / 2)) / div;
 123 }
 124
 125 static int
 126 nv50_set_intensity(struct backlight_device *bd)
 127 {
 128         struct nouveau_encoder *nv_encoder = bl_get_data(bd);
 129         struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
 130         struct nvif_object *device = &drm->client.device.object;
 131         int or = ffs(nv_encoder->dcb->or) - 1;
 132         u32 div = 1025;
 133         u32 val = (bd->props.brightness * div) / 100;
 134
 135         nvif_wr32(device, NV50_PDISP_SOR_PWM_CTL(or),
 136                   NV50_PDISP_SOR_PWM_CTL_NEW | val);
 137         return 0;
 138 }
 139
 140 static const struct backlight_ops nv50_bl_ops = {
 141         .options = BL_CORE_SUSPENDRESUME,
 142         .get_brightness = nv50_get_intensity,
 143         .update_status = nv50_set_intensity,
 144 };
 145
 146 /*
 147  * eDP brightness callbacks need to happen under lock, since we need to
 148  * enable/disable the backlight ourselves for modesets
 149  */
 150 static int
 151 nv50_edp_get_brightness(struct backlight_device *bd)
 152 {
 153         struct drm_connector *connector = dev_get_drvdata(bd->dev.parent);
 154         struct drm_device *dev = connector->dev;
 155         struct drm_crtc *crtc;
 156         struct drm_modeset_acquire_ctx ctx;
 157         int ret = 0;
 158
 159         drm_modeset_acquire_init(&ctx, 0);
 160
 161 retry:
 162         ret = drm_modeset_lock(&dev->mode_config.connection_mutex, &ctx);
 163         if (ret == -EDEADLK)
 164                 goto deadlock;
 165         else if (ret < 0)
 166                 goto out;
 167
 168         crtc = connector->state->crtc;
 169         if (!crtc)
 170                 goto out;
 171
 172         ret = drm_modeset_lock(&crtc->mutex, &ctx);
 173         if (ret == -EDEADLK)
 174                 goto deadlock;
 175         else if (ret < 0)
 176                 goto out;
 177
 178         if (!crtc->state->active)
 179                 goto out;
 180
 181         ret = bd->props.brightness;
 182 out:
 183         drm_modeset_drop_locks(&ctx);
 184         drm_modeset_acquire_fini(&ctx);
 185         return ret;
 186 deadlock:
 187         drm_modeset_backoff(&ctx);
 188         goto retry;
 189 }
 190
 191 static int
 192 nv50_edp_set_brightness(struct backlight_device *bd)
 193 {
 194         struct drm_connector *connector = dev_get_drvdata(bd->dev.parent);
 195         struct nouveau_connector *nv_connector = nouveau_connector(connector);
 196         struct drm_device *dev = connector->dev;
 197         struct drm_crtc *crtc;
 198         struct drm_dp_aux *aux = &nv_connector->aux;
 199         struct nouveau_backlight *nv_bl = nv_connector->backlight;
 200         struct drm_modeset_acquire_ctx ctx;
 201         int ret = 0;
 202
 203         drm_modeset_acquire_init(&ctx, 0);
 204 retry:
 205         ret = drm_modeset_lock(&dev->mode_config.connection_mutex, &ctx);
 206         if (ret == -EDEADLK)
 207                 goto deadlock;
 208         else if (ret < 0)
 209                 goto out;
 210
 211         crtc = connector->state->crtc;
 212         if (!crtc)
 213                 goto out;
 214
 215         ret = drm_modeset_lock(&crtc->mutex, &ctx);
 216         if (ret == -EDEADLK)
 217                 goto deadlock;
 218         else if (ret < 0)
 219                 goto out;
 220
 221         if (crtc->state->active)
 222                 ret = drm_edp_backlight_set_level(aux, &nv_bl->edp_info, bd->props.brightness);
 223
 224 out:
 225         drm_modeset_drop_locks(&ctx);
 226         drm_modeset_acquire_fini(&ctx);
 227         return ret;
 228 deadlock:
 229         drm_modeset_backoff(&ctx);
 230         goto retry;
 231 }
 232
 233 static const struct backlight_ops nv50_edp_bl_ops = {
 234         .get_brightness = nv50_edp_get_brightness,
 235         .update_status = nv50_edp_set_brightness,
 236 };
 237
 238 static int
 239 nva3_get_intensity(struct backlight_device *bd)
 240 {
 241         struct nouveau_encoder *nv_encoder = bl_get_data(bd);
 242         struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
 243         struct nvif_object *device = &drm->client.device.object;
 244         int or = ffs(nv_encoder->dcb->or) - 1;
 245         u32 div, val;
 246
 247         div  = nvif_rd32(device, NV50_PDISP_SOR_PWM_DIV(or));
 248         val  = nvif_rd32(device, NV50_PDISP_SOR_PWM_CTL(or));
 249         val &= NVA3_PDISP_SOR_PWM_CTL_VAL;
 250         if (div && div >= val)
 251                 return ((val * 100) + (div / 2)) / div;
 252
 253         return 100;
 254 }
 255
 256 static int
 257 nva3_set_intensity(struct backlight_device *bd)
 258 {
 259         struct nouveau_encoder *nv_encoder = bl_get_data(bd);
 260         struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
 261         struct nvif_object *device = &drm->client.device.object;
 262         int or = ffs(nv_encoder->dcb->or) - 1;
 263         u32 div, val;
 264
 265         div = nvif_rd32(device, NV50_PDISP_SOR_PWM_DIV(or));
 266         val = (bd->props.brightness * div) / 100;
 267         if (div) {
 268                 nvif_wr32(device, NV50_PDISP_SOR_PWM_CTL(or),
 269                           val |
 270                           NV50_PDISP_SOR_PWM_CTL_NEW |
 271                           NVA3_PDISP_SOR_PWM_CTL_UNK);
 272                 return 0;
 273         }
 274
 275         return -EINVAL;
 276 }
 277
 278 static const struct backlight_ops nva3_bl_ops = {
 279         .options = BL_CORE_SUSPENDRESUME,
 280         .get_brightness = nva3_get_intensity,
 281         .update_status = nva3_set_intensity,
 282 };
 283
 284 /* FIXME: perform backlight probing for eDP _before_ this, this only gets called after connector
 285  * registration which happens after the initial modeset
 286  */
 287 static int
 288 nv50_backlight_init(struct nouveau_backlight *bl,
 289                     struct nouveau_connector *nv_conn,
 290                     struct nouveau_encoder *nv_encoder,
 291                     struct backlight_properties *props,
 292                     const struct backlight_ops **ops)
 293 {
 294         struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
 295         struct nvif_object *device = &drm->client.device.object;
 296
 297         if (!nvif_rd32(device, NV50_PDISP_SOR_PWM_CTL(ffs(nv_encoder->dcb->or) - 1)) ||
 298             nv_conn->base.status != connector_status_connected)
 299                 return -ENODEV;
 300
 301         if (nv_conn->type == DCB_CONNECTOR_eDP) {
 302                 int ret;
 303                 u16 current_level;
 304                 u8 edp_dpcd[EDP_DISPLAY_CTL_CAP_SIZE];
 305                 u8 current_mode;
 306
 307                 ret = drm_dp_dpcd_read(&nv_conn->aux, DP_EDP_DPCD_REV, edp_dpcd,
 308                                        EDP_DISPLAY_CTL_CAP_SIZE);
 309                 if (ret < 0)
 310                         return ret;
 311
 312                 /* TODO: Add support for hybrid PWM/DPCD panels */
 313                 if (drm_edp_backlight_supported(edp_dpcd) &&
 314                     (edp_dpcd[1] & DP_EDP_BACKLIGHT_AUX_ENABLE_CAP) &&
 315                     (edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_AUX_SET_CAP)) {
 316                         NV_DEBUG(drm, "DPCD backlight controls supported on %s\n",
 317                                  nv_conn->base.name);
 318
 319                         ret = drm_edp_backlight_init(&nv_conn->aux, &bl->edp_info, 0, edp_dpcd,
 320                                                      &current_level, &current_mode);
 321                         if (ret < 0)
 322                                 return ret;
 323
 324                         ret = drm_edp_backlight_enable(&nv_conn->aux, &bl->edp_info, current_level);
 325                         if (ret < 0) {
 326                                 NV_ERROR(drm, "Failed to enable backlight on %s: %d\n",
 327                                          nv_conn->base.name, ret);
 328                                 return ret;
 329                         }
 330
 331                         *ops = &nv50_edp_bl_ops;
 332                         props->brightness = current_level;
 333                         props->max_brightness = bl->edp_info.max;
 334                         bl->uses_dpcd = true;
 335                         return 0;
 336                 }
 337         }
 338
 339         if (drm->client.device.info.chipset <= 0xa0 ||
 340             drm->client.device.info.chipset == 0xaa ||
 341             drm->client.device.info.chipset == 0xac)
 342                 *ops = &nv50_bl_ops;
 343         else
 344                 *ops = &nva3_bl_ops;
 345
 346         props->max_brightness = 100;
 347
 348         return 0;
 349 }
 350
 351 int
 352 nouveau_backlight_init(struct drm_connector *connector)
 353 {
 354         struct nouveau_drm *drm = nouveau_drm(connector->dev);
 355         struct nouveau_backlight *bl;
 356         struct nouveau_encoder *nv_encoder = NULL;
 357         struct nvif_device *device = &drm->client.device;
 358         char backlight_name[BL_NAME_SIZE];
 359         struct backlight_properties props = {0};
 360         const struct backlight_ops *ops;
 361         int ret;
 362
 363         if (apple_gmux_present()) {
 364                 NV_INFO_ONCE(drm, "Apple GMUX detected: not registering Nouveau backlight interface\n");
 365                 return 0;
 366         }
 367
 368         if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)
 369                 nv_encoder = find_encoder(connector, DCB_OUTPUT_LVDS);
 370         else if (connector->connector_type == DRM_MODE_CONNECTOR_eDP)
 371                 nv_encoder = find_encoder(connector, DCB_OUTPUT_DP);
 372         else
 373                 return 0;
 374
 375         if (!nv_encoder)
 376                 return 0;
 377
 378         bl = kzalloc(sizeof(*bl), GFP_KERNEL);
 379         if (!bl)
 380                 return -ENOMEM;
 381
 382         switch (device->info.family) {
 383         case NV_DEVICE_INFO_V0_CURIE:
 384                 ret = nv40_backlight_init(nv_encoder, &props, &ops);
 385                 break;
 386         case NV_DEVICE_INFO_V0_TESLA:
 387         case NV_DEVICE_INFO_V0_FERMI:
 388         case NV_DEVICE_INFO_V0_KEPLER:
 389         case NV_DEVICE_INFO_V0_MAXWELL:
 390         case NV_DEVICE_INFO_V0_PASCAL:
 391         case NV_DEVICE_INFO_V0_VOLTA:
 392         case NV_DEVICE_INFO_V0_TURING:
 393         case NV_DEVICE_INFO_V0_AMPERE: //XXX: not confirmed
 394                 ret = nv50_backlight_init(bl, nouveau_connector(connector),
 395                                           nv_encoder, &props, &ops);
 396                 break;
 397         default:
 398                 ret = 0;
 399                 goto fail_alloc;
 400         }
 401
 402         if (ret) {
 403                 if (ret == -ENODEV)
 404                         ret = 0;
 405                 goto fail_alloc;
 406         }
 407
 408         if (!nouveau_get_backlight_name(backlight_name, bl)) {
 409                 NV_ERROR(drm, "Failed to retrieve a unique name for the backlight interface\n");
 410                 goto fail_alloc;
 411         }
 412
 413         props.type = BACKLIGHT_RAW;
 414         bl->dev = backlight_device_register(backlight_name, connector->kdev,
 415                                             nv_encoder, ops, &props);
 416         if (IS_ERR(bl->dev)) {
 417                 if (bl->id >= 0)
 418                         ida_free(&bl_ida, bl->id);
 419                 ret = PTR_ERR(bl->dev);
 420                 goto fail_alloc;
 421         }
 422
 423         nouveau_connector(connector)->backlight = bl;
 424         if (!bl->dev->props.brightness)
 425                 bl->dev->props.brightness =
 426                         bl->dev->ops->get_brightness(bl->dev);
 427         backlight_update_status(bl->dev);
 428
 429         return 0;
 430
 431 fail_alloc:
 432         kfree(bl);
 433         return ret;
 434 }
 435
 436 void
 437 nouveau_backlight_fini(struct drm_connector *connector)
 438 {
 439         struct nouveau_connector *nv_conn = nouveau_connector(connector);
 440         struct nouveau_backlight *bl = nv_conn->backlight;
 441
 442         if (!bl)
 443                 return;
 444
 445         if (bl->id >= 0)
 446                 ida_free(&bl_ida, bl->id);
 447
 448         backlight_device_unregister(bl->dev);
 449         nv_conn->backlight = NULL;
 450         kfree(bl);
 451 }
 452
 453 void
 454 nouveau_backlight_ctor(void)
 455 {
 456         ida_init(&bl_ida);
 457 }
 458
 459 void
 460 nouveau_backlight_dtor(void)
 461 {
 462         ida_destroy(&bl_ida);
 463 }