xref: /linux/drivers/gpu/drm/nouveau/nouveau_display.c (revision ed7fb901fce31588bd12ab95adc36ebcb51bc8ea)
1 /*
2  * Copyright (C) 2008 Maarten Maathuis.
3  * All Rights Reserved.
4  *
5  * Permission is hereby granted, free of charge, to any person obtaining
6  * a copy of this software and associated documentation files (the
7  * "Software"), to deal in the Software without restriction, including
8  * without limitation the rights to use, copy, modify, merge, publish,
9  * distribute, sublicense, and/or sell copies of the Software, and to
10  * permit persons to whom the Software is furnished to do so, subject to
11  * the following conditions:
12  *
13  * The above copyright notice and this permission notice (including the
14  * next paragraph) shall be included in all copies or substantial
15  * portions of the Software.
16  *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
20  * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
21  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
22  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
23  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24  *
25  */
26 
27 #include <acpi/video.h>
28 
29 #include <drm/drm_atomic.h>
30 #include <drm/drm_atomic_helper.h>
31 #include <drm/drm_client_event.h>
32 #include <drm/drm_crtc_helper.h>
33 #include <drm/drm_dumb_buffers.h>
34 #include <drm/drm_fourcc.h>
35 #include <drm/drm_gem_framebuffer_helper.h>
36 #include <drm/drm_probe_helper.h>
37 #include <drm/drm_vblank.h>
38 
39 #include "nouveau_crtc.h"
40 #include "nouveau_gem.h"
41 #include "nouveau_connector.h"
42 #include "nv50_display.h"
43 
44 #include <nvif/class.h>
45 #include <nvif/if0011.h>
46 #include <nvif/if0013.h>
47 #include <dispnv50/crc.h>
48 #include <dispnv50/tile.h>
49 
50 int
51 nouveau_display_vblank_enable(struct drm_crtc *crtc)
52 {
53 	struct nouveau_crtc *nv_crtc;
54 
55 	nv_crtc = nouveau_crtc(crtc);
56 	nvif_event_allow(&nv_crtc->vblank);
57 
58 	return 0;
59 }
60 
61 void
62 nouveau_display_vblank_disable(struct drm_crtc *crtc)
63 {
64 	struct nouveau_crtc *nv_crtc;
65 
66 	nv_crtc = nouveau_crtc(crtc);
67 	nvif_event_block(&nv_crtc->vblank);
68 }
69 
70 static inline int
71 calc(int blanks, int blanke, int total, int line)
72 {
73 	if (blanke >= blanks) {
74 		if (line >= blanks)
75 			line -= total;
76 	} else {
77 		if (line >= blanks)
78 			line -= total;
79 		line -= blanke + 1;
80 	}
81 	return line;
82 }
83 
84 static bool
85 nouveau_display_scanoutpos_head(struct drm_crtc *crtc, int *vpos, int *hpos,
86 				ktime_t *stime, ktime_t *etime)
87 {
88 	struct drm_vblank_crtc *vblank = drm_crtc_vblank_crtc(crtc);
89 	struct nvif_head *head = &nouveau_crtc(crtc)->head;
90 	struct nvif_head_scanoutpos_v0 args;
91 	int retry = 20;
92 	bool ret = false;
93 
94 	args.version = 0;
95 
96 	do {
97 		ret = nvif_mthd(&head->object, NVIF_HEAD_V0_SCANOUTPOS, &args, sizeof(args));
98 		if (ret != 0)
99 			return false;
100 
101 		if (args.vline) {
102 			ret = true;
103 			break;
104 		}
105 
106 		if (retry) ndelay(vblank->linedur_ns);
107 	} while (retry--);
108 
109 	*hpos = args.hline;
110 	*vpos = calc(args.vblanks, args.vblanke, args.vtotal, args.vline);
111 	if (stime) *stime = ns_to_ktime(args.time[0]);
112 	if (etime) *etime = ns_to_ktime(args.time[1]);
113 
114 	return ret;
115 }
116 
117 bool
118 nouveau_display_scanoutpos(struct drm_crtc *crtc,
119 			   bool in_vblank_irq, int *vpos, int *hpos,
120 			   ktime_t *stime, ktime_t *etime,
121 			   const struct drm_display_mode *mode)
122 {
123 	return nouveau_display_scanoutpos_head(crtc, vpos, hpos,
124 					       stime, etime);
125 }
126 
127 static const struct drm_framebuffer_funcs nouveau_framebuffer_funcs = {
128 	.destroy = drm_gem_fb_destroy,
129 	.create_handle = drm_gem_fb_create_handle,
130 };
131 
132 static void
133 nouveau_decode_mod(struct nouveau_drm *drm,
134 		   uint64_t modifier,
135 		   uint32_t *tile_mode,
136 		   uint8_t *kind)
137 {
138 	struct nouveau_display *disp = nouveau_display(drm->dev);
139 	BUG_ON(!tile_mode || !kind);
140 
141 	if (modifier == DRM_FORMAT_MOD_LINEAR) {
142 		/* tile_mode will not be used in this case */
143 		*tile_mode = 0;
144 		*kind = 0;
145 	} else {
146 		/*
147 		 * Extract the block height and kind from the corresponding
148 		 * modifier fields.  See drm_fourcc.h for details.
149 		 */
150 
151 		if ((modifier & (0xffull << 12)) == 0ull) {
152 			/* Legacy modifier.  Translate to this dev's 'kind.' */
153 			modifier |= disp->format_modifiers[0] & (0xffull << 12);
154 		}
155 
156 		*tile_mode = (uint32_t)(modifier & 0xF);
157 		*kind = (uint8_t)((modifier >> 12) & 0xFF);
158 
159 		if (drm->client.device.info.chipset >= 0xc0)
160 			*tile_mode <<= 4;
161 	}
162 }
163 
164 void
165 nouveau_framebuffer_get_layout(struct drm_framebuffer *fb,
166 			       uint32_t *tile_mode,
167 			       uint8_t *kind)
168 {
169 	if (fb->flags & DRM_MODE_FB_MODIFIERS) {
170 		struct nouveau_drm *drm = nouveau_drm(fb->dev);
171 
172 		nouveau_decode_mod(drm, fb->modifier, tile_mode, kind);
173 	} else {
174 		const struct nouveau_bo *nvbo = nouveau_gem_object(fb->obj[0]);
175 
176 		*tile_mode = nvbo->mode;
177 		*kind = nvbo->kind;
178 	}
179 }
180 
181 static const u64 legacy_modifiers[] = {
182 	DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(0),
183 	DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(1),
184 	DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(2),
185 	DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(3),
186 	DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(4),
187 	DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(5),
188 	DRM_FORMAT_MOD_INVALID
189 };
190 
191 static int
192 nouveau_validate_decode_mod(struct nouveau_drm *drm,
193 			    uint64_t modifier,
194 			    uint32_t *tile_mode,
195 			    uint8_t *kind)
196 {
197 	struct nouveau_display *disp = nouveau_display(drm->dev);
198 	int mod;
199 
200 	if (drm->client.device.info.family < NV_DEVICE_INFO_V0_TESLA) {
201 		return -EINVAL;
202 	}
203 
204 	BUG_ON(!disp->format_modifiers);
205 
206 	for (mod = 0;
207 	     (disp->format_modifiers[mod] != DRM_FORMAT_MOD_INVALID) &&
208 	     (disp->format_modifiers[mod] != modifier);
209 	     mod++);
210 
211 	if (disp->format_modifiers[mod] == DRM_FORMAT_MOD_INVALID) {
212 		for (mod = 0;
213 		     (legacy_modifiers[mod] != DRM_FORMAT_MOD_INVALID) &&
214 		     (legacy_modifiers[mod] != modifier);
215 		     mod++);
216 		if (legacy_modifiers[mod] == DRM_FORMAT_MOD_INVALID)
217 			return -EINVAL;
218 	}
219 
220 	nouveau_decode_mod(drm, modifier, tile_mode, kind);
221 
222 	return 0;
223 }
224 
225 static int
226 nouveau_check_bl_size(struct nouveau_drm *drm, struct nouveau_bo *nvbo,
227 		      uint32_t offset, uint32_t stride, uint32_t h,
228 		      uint32_t tile_mode)
229 {
230 	uint32_t gob_size, bw, bh, gobs_in_block;
231 	uint64_t bl_size;
232 
233 	BUG_ON(drm->client.device.info.family < NV_DEVICE_INFO_V0_TESLA);
234 
235 	if (nouveau_check_tile_mode(tile_mode, drm->client.device.info.chipset))
236 		return -EINVAL;
237 
238 	gobs_in_block = nouveau_get_gobs_in_block(tile_mode, drm->client.device.info.chipset);
239 	bw = nouveau_get_width_in_blocks(stride);
240 	bh = nouveau_get_height_in_blocks(h, gobs_in_block, drm->client.device.info.family);
241 	gob_size = nouveau_get_gob_size(drm->client.device.info.family);
242 
243 	bl_size = bw * bh * gobs_in_block * gob_size;
244 
245 	DRM_DEBUG_KMS("offset=%u stride=%u h=%u gobs_in_block=%u bw=%u bh=%u gob_size=%u bl_size=%llu size=%zu\n",
246 		      offset, stride, h, gobs_in_block, bw, bh, gob_size,
247 		      bl_size, nvbo->bo.base.size);
248 
249 	if (bl_size + offset > nvbo->bo.base.size)
250 		return -ERANGE;
251 
252 	return 0;
253 }
254 
255 int
256 nouveau_framebuffer_new(struct drm_device *dev,
257 			const struct drm_format_info *info,
258 			const struct drm_mode_fb_cmd2 *mode_cmd,
259 			struct drm_gem_object *gem,
260 			struct drm_framebuffer **pfb)
261 {
262 	struct nouveau_drm *drm = nouveau_drm(dev);
263 	struct nouveau_bo *nvbo = nouveau_gem_object(gem);
264 	struct drm_framebuffer *fb;
265 	unsigned int height, i;
266 	uint32_t tile_mode;
267 	uint8_t kind;
268 	int ret;
269 
270         /* YUV overlays have special requirements pre-NV50 */
271 	if (drm->client.device.info.family < NV_DEVICE_INFO_V0_TESLA &&
272 
273 	    (mode_cmd->pixel_format == DRM_FORMAT_YUYV ||
274 	     mode_cmd->pixel_format == DRM_FORMAT_UYVY ||
275 	     mode_cmd->pixel_format == DRM_FORMAT_NV12 ||
276 	     mode_cmd->pixel_format == DRM_FORMAT_NV21) &&
277 	    (mode_cmd->pitches[0] & 0x3f || /* align 64 */
278 	     mode_cmd->pitches[0] >= 0x10000 || /* at most 64k pitch */
279 	     (mode_cmd->pitches[1] && /* pitches for planes must match */
280 	      mode_cmd->pitches[0] != mode_cmd->pitches[1]))) {
281 		DRM_DEBUG_KMS("Unsuitable framebuffer: format: %p4cc; pitches: 0x%x\n 0x%x\n",
282 			      &mode_cmd->pixel_format,
283 			      mode_cmd->pitches[0], mode_cmd->pitches[1]);
284 		return -EINVAL;
285 	}
286 
287 	if (mode_cmd->flags & DRM_MODE_FB_MODIFIERS) {
288 		if (nouveau_validate_decode_mod(drm, mode_cmd->modifier[0],
289 						&tile_mode, &kind)) {
290 			DRM_DEBUG_KMS("Unsupported modifier: 0x%llx\n",
291 				      mode_cmd->modifier[0]);
292 			return -EINVAL;
293 		}
294 	} else {
295 		tile_mode = nvbo->mode;
296 		kind = nvbo->kind;
297 	}
298 
299 	for (i = 0; i < info->num_planes; i++) {
300 		height = drm_format_info_plane_height(info,
301 						      mode_cmd->height,
302 						      i);
303 
304 		if (kind) {
305 			ret = nouveau_check_bl_size(drm, nvbo,
306 						    mode_cmd->offsets[i],
307 						    mode_cmd->pitches[i],
308 						    height, tile_mode);
309 			if (ret)
310 				return ret;
311 		} else {
312 			uint32_t size = mode_cmd->pitches[i] * height;
313 
314 			if (size + mode_cmd->offsets[i] > nvbo->bo.base.size)
315 				return -ERANGE;
316 		}
317 	}
318 
319 	if (!(fb = *pfb = kzalloc_obj(*fb)))
320 		return -ENOMEM;
321 
322 	drm_helper_mode_fill_fb_struct(dev, fb, info, mode_cmd);
323 	fb->obj[0] = gem;
324 
325 	ret = drm_framebuffer_init(dev, fb, &nouveau_framebuffer_funcs);
326 	if (ret)
327 		kfree(fb);
328 	return ret;
329 }
330 
331 struct drm_framebuffer *
332 nouveau_user_framebuffer_create(struct drm_device *dev,
333 				struct drm_file *file_priv,
334 				const struct drm_format_info *info,
335 				const struct drm_mode_fb_cmd2 *mode_cmd)
336 {
337 	struct drm_framebuffer *fb;
338 	struct drm_gem_object *gem;
339 	int ret;
340 
341 	gem = drm_gem_object_lookup(file_priv, mode_cmd->handles[0]);
342 	if (!gem)
343 		return ERR_PTR(-ENOENT);
344 
345 	ret = nouveau_framebuffer_new(dev, info, mode_cmd, gem, &fb);
346 	if (ret == 0)
347 		return fb;
348 
349 	drm_gem_object_put(gem);
350 	return ERR_PTR(ret);
351 }
352 
353 static const struct drm_mode_config_funcs nouveau_mode_config_funcs = {
354 	.fb_create = nouveau_user_framebuffer_create,
355 };
356 
357 static const struct drm_mode_config_funcs nouveau_mode_config_funcs_atomic = {
358 	.fb_create = nouveau_user_framebuffer_create,
359 	.atomic_commit = drm_atomic_helper_commit,
360 	.atomic_check = drm_atomic_helper_check,
361 };
362 
363 struct nouveau_drm_prop_enum_list {
364 	u8 gen_mask;
365 	int type;
366 	char *name;
367 };
368 
369 static struct nouveau_drm_prop_enum_list underscan[] = {
370 	{ 6, UNDERSCAN_AUTO, "auto" },
371 	{ 6, UNDERSCAN_OFF, "off" },
372 	{ 6, UNDERSCAN_ON, "on" },
373 	{}
374 };
375 
376 static struct nouveau_drm_prop_enum_list dither_mode[] = {
377 	{ 7, DITHERING_MODE_AUTO, "auto" },
378 	{ 7, DITHERING_MODE_OFF, "off" },
379 	{ 1, DITHERING_MODE_ON, "on" },
380 	{ 6, DITHERING_MODE_STATIC2X2, "static 2x2" },
381 	{ 6, DITHERING_MODE_DYNAMIC2X2, "dynamic 2x2" },
382 	{ 4, DITHERING_MODE_TEMPORAL, "temporal" },
383 	{}
384 };
385 
386 static struct nouveau_drm_prop_enum_list dither_depth[] = {
387 	{ 6, DITHERING_DEPTH_AUTO, "auto" },
388 	{ 6, DITHERING_DEPTH_6BPC, "6 bpc" },
389 	{ 6, DITHERING_DEPTH_8BPC, "8 bpc" },
390 	{}
391 };
392 
393 #define PROP_ENUM(p,gen,n,list) do {                                           \
394 	struct nouveau_drm_prop_enum_list *l = (list);                         \
395 	int c = 0;                                                             \
396 	while (l->gen_mask) {                                                  \
397 		if (l->gen_mask & (1 << (gen)))                                \
398 			c++;                                                   \
399 		l++;                                                           \
400 	}                                                                      \
401 	if (c) {                                                               \
402 		p = drm_property_create(dev, DRM_MODE_PROP_ENUM, n, c);        \
403 		l = (list);                                                    \
404 		while (p && l->gen_mask) {                                     \
405 			if (l->gen_mask & (1 << (gen))) {                      \
406 				drm_property_add_enum(p, l->type, l->name);    \
407 			}                                                      \
408 			l++;                                                   \
409 		}                                                              \
410 	}                                                                      \
411 } while(0)
412 
413 void
414 nouveau_display_hpd_resume(struct nouveau_drm *drm)
415 {
416 	if (drm->headless)
417 		return;
418 
419 	spin_lock_irq(&drm->hpd_lock);
420 	drm->hpd_pending = ~0;
421 	spin_unlock_irq(&drm->hpd_lock);
422 
423 	schedule_work(&drm->hpd_work);
424 }
425 
426 static void
427 nouveau_display_hpd_work(struct work_struct *work)
428 {
429 	struct nouveau_drm *drm = container_of(work, typeof(*drm), hpd_work);
430 	struct drm_device *dev = drm->dev;
431 	struct drm_connector *connector;
432 	struct drm_connector_list_iter conn_iter;
433 	u32 pending;
434 	int changed = 0;
435 	struct drm_connector *first_changed_connector = NULL;
436 
437 	pm_runtime_get_sync(dev->dev);
438 
439 	spin_lock_irq(&drm->hpd_lock);
440 	pending = drm->hpd_pending;
441 	drm->hpd_pending = 0;
442 	spin_unlock_irq(&drm->hpd_lock);
443 
444 	/* Nothing to do, exit early without updating the last busy counter */
445 	if (!pending)
446 		goto noop;
447 
448 	mutex_lock(&dev->mode_config.mutex);
449 	drm_connector_list_iter_begin(dev, &conn_iter);
450 
451 	nouveau_for_each_non_mst_connector_iter(connector, &conn_iter) {
452 		struct nouveau_connector *nv_connector = nouveau_connector(connector);
453 		enum drm_connector_status old_status = connector->status;
454 		u64 bits, old_epoch_counter = connector->epoch_counter;
455 
456 		if (!(pending & drm_connector_mask(connector)))
457 			continue;
458 
459 		spin_lock_irq(&drm->hpd_lock);
460 		bits = nv_connector->hpd_pending;
461 		nv_connector->hpd_pending = 0;
462 		spin_unlock_irq(&drm->hpd_lock);
463 
464 		drm_dbg_kms(dev, "[CONNECTOR:%d:%s] plug:%d unplug:%d irq:%d\n",
465 			    connector->base.id, connector->name,
466 			    !!(bits & NVIF_CONN_EVENT_V0_PLUG),
467 			    !!(bits & NVIF_CONN_EVENT_V0_UNPLUG),
468 			    !!(bits & NVIF_CONN_EVENT_V0_IRQ));
469 
470 		if (bits & NVIF_CONN_EVENT_V0_IRQ) {
471 			if (nouveau_dp_link_check(nv_connector))
472 				continue;
473 		}
474 
475 		connector->status = drm_helper_probe_detect(connector, NULL, false);
476 		if (old_epoch_counter == connector->epoch_counter)
477 			continue;
478 
479 		changed++;
480 		if (!first_changed_connector) {
481 			drm_connector_get(connector);
482 			first_changed_connector = connector;
483 		}
484 
485 		drm_dbg_kms(dev, "[CONNECTOR:%d:%s] status updated from %s to %s (epoch counter %llu->%llu)\n",
486 			    connector->base.id, connector->name,
487 			    drm_get_connector_status_name(old_status),
488 			    drm_get_connector_status_name(connector->status),
489 			    old_epoch_counter, connector->epoch_counter);
490 	}
491 
492 	drm_connector_list_iter_end(&conn_iter);
493 	mutex_unlock(&dev->mode_config.mutex);
494 
495 	if (changed == 1)
496 		drm_kms_helper_connector_hotplug_event(first_changed_connector);
497 	else if (changed > 0)
498 		drm_kms_helper_hotplug_event(dev);
499 
500 	if (first_changed_connector)
501 		drm_connector_put(first_changed_connector);
502 
503 	pm_runtime_mark_last_busy(dev->dev);
504 noop:
505 	pm_runtime_put_autosuspend(dev->dev);
506 }
507 
508 #ifdef CONFIG_ACPI
509 
510 static int
511 nouveau_display_acpi_ntfy(struct notifier_block *nb, unsigned long val,
512 			  void *data)
513 {
514 	struct nouveau_drm *drm = container_of(nb, typeof(*drm), acpi_nb);
515 	struct acpi_bus_event *info = data;
516 	int ret;
517 
518 	if (!strcmp(info->device_class, ACPI_VIDEO_CLASS)) {
519 		if (info->type == ACPI_VIDEO_NOTIFY_PROBE) {
520 			ret = pm_runtime_get(drm->dev->dev);
521 			if (ret == 1 || ret == -EACCES) {
522 				/* If the GPU is already awake, or in a state
523 				 * where we can't wake it up, it can handle
524 				 * it's own hotplug events.
525 				 */
526 				pm_runtime_put_autosuspend(drm->dev->dev);
527 			} else if (ret == 0 || ret == -EINPROGRESS) {
528 				/* We've started resuming the GPU already, so
529 				 * it will handle scheduling a full reprobe
530 				 * itself
531 				 */
532 				NV_DEBUG(drm, "ACPI requested connector reprobe\n");
533 				pm_runtime_put_noidle(drm->dev->dev);
534 			} else {
535 				NV_WARN(drm, "Dropped ACPI reprobe event due to RPM error: %d\n",
536 					ret);
537 			}
538 
539 			/* acpi-video should not generate keypresses for this */
540 			return NOTIFY_BAD;
541 		}
542 	}
543 
544 	return NOTIFY_DONE;
545 }
546 #endif
547 
548 int
549 nouveau_display_init(struct drm_device *dev, bool resume, bool runtime)
550 {
551 	struct nouveau_display *disp = nouveau_display(dev);
552 	struct drm_connector *connector;
553 	struct drm_connector_list_iter conn_iter;
554 	int ret;
555 
556 	/*
557 	 * Enable hotplug interrupts (done as early as possible, since we need
558 	 * them for MST)
559 	 */
560 	drm_connector_list_iter_begin(dev, &conn_iter);
561 	nouveau_for_each_non_mst_connector_iter(connector, &conn_iter) {
562 		struct nouveau_connector *conn = nouveau_connector(connector);
563 		nvif_event_allow(&conn->hpd);
564 		nvif_event_allow(&conn->irq);
565 	}
566 	drm_connector_list_iter_end(&conn_iter);
567 
568 	ret = disp->init(dev, resume, runtime);
569 	if (ret)
570 		return ret;
571 
572 	/* enable connector detection and polling for connectors without HPD
573 	 * support
574 	 */
575 	drm_kms_helper_poll_enable(dev);
576 
577 	return ret;
578 }
579 
580 void
581 nouveau_display_fini(struct drm_device *dev, bool suspend, bool runtime)
582 {
583 	struct nouveau_display *disp = nouveau_display(dev);
584 	struct nouveau_drm *drm = nouveau_drm(dev);
585 	struct drm_connector *connector;
586 	struct drm_connector_list_iter conn_iter;
587 
588 	if (!suspend) {
589 		if (drm_drv_uses_atomic_modeset(dev))
590 			drm_atomic_helper_shutdown(dev);
591 		else
592 			drm_helper_force_disable_all(dev);
593 	}
594 
595 	/* disable hotplug interrupts */
596 	drm_connector_list_iter_begin(dev, &conn_iter);
597 	nouveau_for_each_non_mst_connector_iter(connector, &conn_iter) {
598 		struct nouveau_connector *conn = nouveau_connector(connector);
599 		nvif_event_block(&conn->irq);
600 		nvif_event_block(&conn->hpd);
601 	}
602 	drm_connector_list_iter_end(&conn_iter);
603 
604 	if (!runtime && !drm->headless)
605 		cancel_work_sync(&drm->hpd_work);
606 
607 	drm_kms_helper_poll_disable(dev);
608 	disp->fini(dev, runtime, suspend);
609 }
610 
611 static void
612 nouveau_display_create_properties(struct drm_device *dev)
613 {
614 	struct nouveau_display *disp = nouveau_display(dev);
615 	int gen;
616 
617 	if (disp->disp.object.oclass < NV50_DISP)
618 		gen = 0;
619 	else
620 	if (disp->disp.object.oclass < GF110_DISP)
621 		gen = 1;
622 	else
623 		gen = 2;
624 
625 	PROP_ENUM(disp->dithering_mode, gen, "dithering mode", dither_mode);
626 	PROP_ENUM(disp->dithering_depth, gen, "dithering depth", dither_depth);
627 	PROP_ENUM(disp->underscan_property, gen, "underscan", underscan);
628 
629 	disp->underscan_hborder_property =
630 		drm_property_create_range(dev, 0, "underscan hborder", 0, 128);
631 
632 	disp->underscan_vborder_property =
633 		drm_property_create_range(dev, 0, "underscan vborder", 0, 128);
634 
635 	if (gen < 1)
636 		return;
637 
638 	/* -90..+90 */
639 	disp->vibrant_hue_property =
640 		drm_property_create_range(dev, 0, "vibrant hue", 0, 180);
641 
642 	/* -100..+100 */
643 	disp->color_vibrance_property =
644 		drm_property_create_range(dev, 0, "color vibrance", 0, 200);
645 }
646 
647 int
648 nouveau_display_create(struct drm_device *dev)
649 {
650 	struct nouveau_drm *drm = nouveau_drm(dev);
651 	struct nouveau_display *disp;
652 	int ret;
653 
654 	disp = drm->display = kzalloc_obj(*disp);
655 	if (!disp)
656 		return -ENOMEM;
657 
658 	drm_mode_config_init(dev);
659 	drm_mode_create_scaling_mode_property(dev);
660 	drm_mode_create_dvi_i_properties(dev);
661 
662 	/* this only gets set if the driver has the ATOMIC flag */
663 	if (drm_drv_uses_atomic_modeset(dev))
664 		dev->mode_config.funcs = &nouveau_mode_config_funcs_atomic;
665 	else
666 		dev->mode_config.funcs = &nouveau_mode_config_funcs;
667 
668 	dev->mode_config.min_width = 0;
669 	dev->mode_config.min_height = 0;
670 	if (drm->client.device.info.family < NV_DEVICE_INFO_V0_CELSIUS) {
671 		dev->mode_config.max_width = 2048;
672 		dev->mode_config.max_height = 2048;
673 	} else
674 	if (drm->client.device.info.family < NV_DEVICE_INFO_V0_TESLA) {
675 		dev->mode_config.max_width = 4096;
676 		dev->mode_config.max_height = 4096;
677 	} else
678 	if (drm->client.device.info.family < NV_DEVICE_INFO_V0_FERMI) {
679 		dev->mode_config.max_width = 8192;
680 		dev->mode_config.max_height = 8192;
681 	} else {
682 		dev->mode_config.max_width = 16384;
683 		dev->mode_config.max_height = 16384;
684 	}
685 
686 	dev->mode_config.preferred_depth = 24;
687 	dev->mode_config.prefer_shadow = 1;
688 
689 	if (drm->client.device.info.chipset < 0x11)
690 		dev->mode_config.async_page_flip = false;
691 	else
692 		dev->mode_config.async_page_flip = true;
693 
694 	drm_kms_helper_poll_init(dev);
695 	drm_kms_helper_poll_disable(dev);
696 
697 	if (nouveau_modeset != 2) {
698 		ret = nvif_disp_ctor(&drm->client.device, "kmsDisp", 0, &disp->disp);
699 		/* no display hw */
700 		if (ret == -ENODEV) {
701 			ret = 0;
702 			drm->headless = true;
703 			goto disp_create_err;
704 		}
705 
706 		if (!ret && (disp->disp.outp_mask || drm->vbios.dcb.entries)) {
707 			nouveau_display_create_properties(dev);
708 			if (disp->disp.object.oclass < NV50_DISP) {
709 				dev->mode_config.fb_modifiers_not_supported = true;
710 				ret = nv04_display_create(dev);
711 			} else {
712 				ret = nv50_display_create(dev);
713 			}
714 		}
715 	} else {
716 		ret = 0;
717 	}
718 
719 	if (ret)
720 		goto disp_create_err;
721 
722 	drm_mode_config_reset(dev);
723 
724 	if (dev->mode_config.num_crtc) {
725 		ret = drm_vblank_init(dev, dev->mode_config.num_crtc);
726 		if (ret)
727 			goto vblank_err;
728 
729 		if (disp->disp.object.oclass >= NV50_DISP)
730 			nv50_crc_init(dev);
731 	}
732 
733 	INIT_WORK(&drm->hpd_work, nouveau_display_hpd_work);
734 	spin_lock_init(&drm->hpd_lock);
735 #ifdef CONFIG_ACPI
736 	drm->acpi_nb.notifier_call = nouveau_display_acpi_ntfy;
737 	register_acpi_notifier(&drm->acpi_nb);
738 #endif
739 
740 	return 0;
741 
742 vblank_err:
743 	disp->dtor(dev);
744 disp_create_err:
745 	drm_kms_helper_poll_fini(dev);
746 	drm_mode_config_cleanup(dev);
747 	return ret;
748 }
749 
750 void
751 nouveau_display_destroy(struct drm_device *dev)
752 {
753 	struct nouveau_display *disp = nouveau_display(dev);
754 	struct nouveau_drm *drm = nouveau_drm(dev);
755 
756 #ifdef CONFIG_ACPI
757 	unregister_acpi_notifier(&drm->acpi_nb);
758 #endif
759 
760 	drm_kms_helper_poll_fini(dev);
761 	drm_mode_config_cleanup(dev);
762 
763 	if (disp->dtor)
764 		disp->dtor(dev);
765 
766 	nvif_disp_dtor(&disp->disp);
767 
768 	drm->display = NULL;
769 	kfree(disp);
770 }
771 
772 int
773 nouveau_display_suspend(struct drm_device *dev, bool runtime)
774 {
775 	struct nouveau_display *disp = nouveau_display(dev);
776 
777 	drm_client_dev_suspend(dev);
778 
779 	if (drm_drv_uses_atomic_modeset(dev)) {
780 		if (!runtime) {
781 			disp->suspend = drm_atomic_helper_suspend(dev);
782 			if (IS_ERR(disp->suspend)) {
783 				int ret = PTR_ERR(disp->suspend);
784 				disp->suspend = NULL;
785 				return ret;
786 			}
787 		}
788 	}
789 
790 	nouveau_display_fini(dev, true, runtime);
791 	return 0;
792 }
793 
794 void
795 nouveau_display_resume(struct drm_device *dev, bool runtime)
796 {
797 	struct nouveau_display *disp = nouveau_display(dev);
798 
799 	nouveau_display_init(dev, true, runtime);
800 
801 	if (drm_drv_uses_atomic_modeset(dev)) {
802 		if (disp->suspend) {
803 			drm_atomic_helper_resume(dev, disp->suspend);
804 			disp->suspend = NULL;
805 		}
806 	}
807 
808 	drm_client_dev_resume(dev);
809 }
810 
811 int
812 nouveau_display_dumb_create(struct drm_file *file_priv, struct drm_device *dev,
813 			    struct drm_mode_create_dumb *args)
814 {
815 	struct nouveau_cli *cli = nouveau_cli(file_priv);
816 	struct nouveau_bo *bo;
817 	uint32_t domain;
818 	int ret;
819 
820 	ret = drm_mode_size_dumb(dev, args, SZ_256, 0);
821 	if (ret)
822 		return ret;
823 
824 	/* Use VRAM if there is any ; otherwise fallback to system memory */
825 	if (nouveau_drm(dev)->client.device.info.ram_size != 0)
826 		domain = NOUVEAU_GEM_DOMAIN_VRAM;
827 	else
828 		domain = NOUVEAU_GEM_DOMAIN_GART;
829 
830 	ret = nouveau_gem_new(cli, args->size, 0, domain, 0, 0, &bo);
831 	if (ret)
832 		return ret;
833 
834 	ret = drm_gem_handle_create(file_priv, &bo->bo.base, &args->handle);
835 	drm_gem_object_put(&bo->bo.base);
836 	return ret;
837 }
838