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