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_simple_get(&bl_ida, 0, 0, GFP_KERNEL); 50 if (nb < 0 || nb >= 100) 51 return false; 52 if (nb > 0) 53 snprintf(backlight_name, BL_NAME_SIZE, "nv_backlight%d", nb); 54 else 55 snprintf(backlight_name, BL_NAME_SIZE, "nv_backlight"); 56 bl->id = nb; 57 return true; 58 } 59 60 static int 61 nv40_get_intensity(struct backlight_device *bd) 62 { 63 struct nouveau_encoder *nv_encoder = bl_get_data(bd); 64 struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev); 65 struct nvif_object *device = &drm->client.device.object; 66 int val = (nvif_rd32(device, NV40_PMC_BACKLIGHT) & 67 NV40_PMC_BACKLIGHT_MASK) >> 16; 68 69 return val; 70 } 71 72 static int 73 nv40_set_intensity(struct backlight_device *bd) 74 { 75 struct nouveau_encoder *nv_encoder = bl_get_data(bd); 76 struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev); 77 struct nvif_object *device = &drm->client.device.object; 78 int val = bd->props.brightness; 79 int reg = nvif_rd32(device, NV40_PMC_BACKLIGHT); 80 81 nvif_wr32(device, NV40_PMC_BACKLIGHT, 82 (val << 16) | (reg & ~NV40_PMC_BACKLIGHT_MASK)); 83 84 return 0; 85 } 86 87 static const struct backlight_ops nv40_bl_ops = { 88 .options = BL_CORE_SUSPENDRESUME, 89 .get_brightness = nv40_get_intensity, 90 .update_status = nv40_set_intensity, 91 }; 92 93 static int 94 nv40_backlight_init(struct nouveau_encoder *encoder, 95 struct backlight_properties *props, 96 const struct backlight_ops **ops) 97 { 98 struct nouveau_drm *drm = nouveau_drm(encoder->base.base.dev); 99 struct nvif_object *device = &drm->client.device.object; 100 101 if (!(nvif_rd32(device, NV40_PMC_BACKLIGHT) & NV40_PMC_BACKLIGHT_MASK)) 102 return -ENODEV; 103 104 props->type = BACKLIGHT_RAW; 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 return -ENODEV; 299 300 if (nv_conn->type == DCB_CONNECTOR_eDP) { 301 int ret; 302 u16 current_level; 303 u8 edp_dpcd[EDP_DISPLAY_CTL_CAP_SIZE]; 304 u8 current_mode; 305 306 ret = drm_dp_dpcd_read(&nv_conn->aux, DP_EDP_DPCD_REV, edp_dpcd, 307 EDP_DISPLAY_CTL_CAP_SIZE); 308 if (ret < 0) 309 return ret; 310 311 /* TODO: Add support for hybrid PWM/DPCD panels */ 312 if (drm_edp_backlight_supported(edp_dpcd) && 313 (edp_dpcd[1] & DP_EDP_BACKLIGHT_AUX_ENABLE_CAP) && 314 (edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_AUX_SET_CAP)) { 315 NV_DEBUG(drm, "DPCD backlight controls supported on %s\n", 316 nv_conn->base.name); 317 318 ret = drm_edp_backlight_init(&nv_conn->aux, &bl->edp_info, 0, edp_dpcd, 319 ¤t_level, ¤t_mode); 320 if (ret < 0) 321 return ret; 322 323 ret = drm_edp_backlight_enable(&nv_conn->aux, &bl->edp_info, current_level); 324 if (ret < 0) { 325 NV_ERROR(drm, "Failed to enable backlight on %s: %d\n", 326 nv_conn->base.name, ret); 327 return ret; 328 } 329 330 *ops = &nv50_edp_bl_ops; 331 props->brightness = current_level; 332 props->max_brightness = bl->edp_info.max; 333 bl->uses_dpcd = true; 334 return 0; 335 } 336 } 337 338 if (drm->client.device.info.chipset <= 0xa0 || 339 drm->client.device.info.chipset == 0xaa || 340 drm->client.device.info.chipset == 0xac) 341 *ops = &nv50_bl_ops; 342 else 343 *ops = &nva3_bl_ops; 344 345 props->type = BACKLIGHT_RAW; 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 bl->dev = backlight_device_register(backlight_name, connector->kdev, 414 nv_encoder, ops, &props); 415 if (IS_ERR(bl->dev)) { 416 if (bl->id >= 0) 417 ida_simple_remove(&bl_ida, bl->id); 418 ret = PTR_ERR(bl->dev); 419 goto fail_alloc; 420 } 421 422 nouveau_connector(connector)->backlight = bl; 423 if (!bl->dev->props.brightness) 424 bl->dev->props.brightness = 425 bl->dev->ops->get_brightness(bl->dev); 426 backlight_update_status(bl->dev); 427 428 return 0; 429 430 fail_alloc: 431 kfree(bl); 432 return ret; 433 } 434 435 void 436 nouveau_backlight_fini(struct drm_connector *connector) 437 { 438 struct nouveau_connector *nv_conn = nouveau_connector(connector); 439 struct nouveau_backlight *bl = nv_conn->backlight; 440 441 if (!bl) 442 return; 443 444 if (bl->id >= 0) 445 ida_simple_remove(&bl_ida, bl->id); 446 447 backlight_device_unregister(bl->dev); 448 nv_conn->backlight = NULL; 449 kfree(bl); 450 } 451 452 void 453 nouveau_backlight_ctor(void) 454 { 455 ida_init(&bl_ida); 456 } 457 458 void 459 nouveau_backlight_dtor(void) 460 { 461 ida_destroy(&bl_ida); 462 } 463