1 /*
2  * Copyright 2009 Red Hat Inc.
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining a
5  * copy of this software and associated documentation files (the "Software"),
6  * to deal in the Software without restriction, including without limitation
7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8  * and/or sell copies of the Software, and to permit persons to whom the
9  * Software is furnished to do so, subject to the following conditions:
10  *
11  * The above copyright notice and this permission notice shall be included in
12  * all copies or substantial portions of the Software.
13  *
14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20  * OTHER DEALINGS IN THE SOFTWARE.
21  *
22  * Author: Ben Skeggs
23  */
24 
25 #include <drm/drmP.h>
26 #include <drm/drm_crtc_helper.h>
27 
28 #include "nouveau_drv.h"
29 #include "nouveau_reg.h"
30 #include "hw.h"
31 #include "nouveau_encoder.h"
32 #include "nouveau_connector.h"
33 #include "nouveau_bo.h"
34 
35 #include <nvif/if0004.h>
36 
37 static void
38 nv04_display_fini(struct drm_device *dev, bool suspend)
39 {
40 	struct nv04_display *disp = nv04_display(dev);
41 	struct drm_crtc *crtc;
42 
43 	/* Disable flip completion events. */
44 	nvif_notify_put(&disp->flip);
45 
46 	/* Disable vblank interrupts. */
47 	NVWriteCRTC(dev, 0, NV_PCRTC_INTR_EN_0, 0);
48 	if (nv_two_heads(dev))
49 		NVWriteCRTC(dev, 1, NV_PCRTC_INTR_EN_0, 0);
50 
51 	if (!suspend)
52 		return;
53 
54 	/* Un-pin FB and cursors so they'll be evicted to system memory. */
55 	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
56 		struct nouveau_framebuffer *nouveau_fb;
57 
58 		nouveau_fb = nouveau_framebuffer(crtc->primary->fb);
59 		if (!nouveau_fb || !nouveau_fb->nvbo)
60 			continue;
61 
62 		nouveau_bo_unpin(nouveau_fb->nvbo);
63 	}
64 
65 	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
66 		struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
67 		if (nv_crtc->cursor.nvbo) {
68 			if (nv_crtc->cursor.set_offset)
69 				nouveau_bo_unmap(nv_crtc->cursor.nvbo);
70 			nouveau_bo_unpin(nv_crtc->cursor.nvbo);
71 		}
72 	}
73 }
74 
75 static int
76 nv04_display_init(struct drm_device *dev, bool resume, bool runtime)
77 {
78 	struct nv04_display *disp = nv04_display(dev);
79 	struct nouveau_drm *drm = nouveau_drm(dev);
80 	struct nouveau_encoder *encoder;
81 	struct drm_crtc *crtc;
82 	int ret;
83 
84 	/* meh.. modeset apparently doesn't setup all the regs and depends
85 	 * on pre-existing state, for now load the state of the card *before*
86 	 * nouveau was loaded, and then do a modeset.
87 	 *
88 	 * best thing to do probably is to make save/restore routines not
89 	 * save/restore "pre-load" state, but more general so we can save
90 	 * on suspend too.
91 	 */
92 	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
93 		struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
94 		nv_crtc->save(&nv_crtc->base);
95 	}
96 
97 	list_for_each_entry(encoder, &dev->mode_config.encoder_list, base.base.head)
98 		encoder->enc_save(&encoder->base.base);
99 
100 	/* Enable flip completion events. */
101 	nvif_notify_get(&disp->flip);
102 
103 	if (!resume)
104 		return 0;
105 
106 	/* Re-pin FB/cursors. */
107 	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
108 		struct nouveau_framebuffer *nouveau_fb;
109 
110 		nouveau_fb = nouveau_framebuffer(crtc->primary->fb);
111 		if (!nouveau_fb || !nouveau_fb->nvbo)
112 			continue;
113 
114 		ret = nouveau_bo_pin(nouveau_fb->nvbo, TTM_PL_FLAG_VRAM, true);
115 		if (ret)
116 			NV_ERROR(drm, "Could not pin framebuffer\n");
117 	}
118 
119 	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
120 		struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
121 		if (!nv_crtc->cursor.nvbo)
122 			continue;
123 
124 		ret = nouveau_bo_pin(nv_crtc->cursor.nvbo, TTM_PL_FLAG_VRAM, true);
125 		if (!ret && nv_crtc->cursor.set_offset)
126 			ret = nouveau_bo_map(nv_crtc->cursor.nvbo);
127 		if (ret)
128 			NV_ERROR(drm, "Could not pin/map cursor.\n");
129 	}
130 
131 	/* Force CLUT to get re-loaded during modeset. */
132 	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
133 		struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
134 
135 		nv_crtc->lut.depth = 0;
136 	}
137 
138 	/* This should ensure we don't hit a locking problem when someone
139 	 * wakes us up via a connector.  We should never go into suspend
140 	 * while the display is on anyways.
141 	 */
142 	if (runtime)
143 		return 0;
144 
145 	/* Restore mode. */
146 	drm_helper_resume_force_mode(dev);
147 
148 	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
149 		struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
150 
151 		if (!nv_crtc->cursor.nvbo)
152 			continue;
153 
154 		if (nv_crtc->cursor.set_offset)
155 			nv_crtc->cursor.set_offset(nv_crtc, nv_crtc->cursor.nvbo->bo.offset);
156 		nv_crtc->cursor.set_pos(nv_crtc, nv_crtc->cursor_saved_x,
157 						 nv_crtc->cursor_saved_y);
158 	}
159 
160 	return 0;
161 }
162 
163 static void
164 nv04_display_destroy(struct drm_device *dev)
165 {
166 	struct nv04_display *disp = nv04_display(dev);
167 	struct nouveau_drm *drm = nouveau_drm(dev);
168 	struct nouveau_encoder *encoder;
169 	struct nouveau_crtc *nv_crtc;
170 
171 	/* Restore state */
172 	list_for_each_entry(encoder, &dev->mode_config.encoder_list, base.base.head)
173 		encoder->enc_restore(&encoder->base.base);
174 
175 	list_for_each_entry(nv_crtc, &dev->mode_config.crtc_list, base.head)
176 		nv_crtc->restore(&nv_crtc->base);
177 
178 	nouveau_hw_save_vga_fonts(dev, 0);
179 
180 	nvif_notify_fini(&disp->flip);
181 
182 	nouveau_display(dev)->priv = NULL;
183 	kfree(disp);
184 
185 	nvif_object_unmap(&drm->client.device.object);
186 }
187 
188 int
189 nv04_display_create(struct drm_device *dev)
190 {
191 	struct nouveau_drm *drm = nouveau_drm(dev);
192 	struct nvkm_i2c *i2c = nvxx_i2c(&drm->client.device);
193 	struct dcb_table *dcb = &drm->vbios.dcb;
194 	struct drm_connector *connector, *ct;
195 	struct drm_encoder *encoder;
196 	struct nouveau_encoder *nv_encoder;
197 	struct nouveau_crtc *crtc;
198 	struct nv04_display *disp;
199 	int i, ret;
200 
201 	disp = kzalloc(sizeof(*disp), GFP_KERNEL);
202 	if (!disp)
203 		return -ENOMEM;
204 
205 	nvif_object_map(&drm->client.device.object, NULL, 0);
206 
207 	nouveau_display(dev)->priv = disp;
208 	nouveau_display(dev)->dtor = nv04_display_destroy;
209 	nouveau_display(dev)->init = nv04_display_init;
210 	nouveau_display(dev)->fini = nv04_display_fini;
211 
212 	/* Pre-nv50 doesn't support atomic, so don't expose the ioctls */
213 	dev->driver->driver_features &= ~DRIVER_ATOMIC;
214 
215 	/* Request page flip completion event. */
216 	if (drm->nvsw.client) {
217 		nvif_notify_init(&drm->nvsw, nv04_flip_complete,
218 				 false, NV04_NVSW_NTFY_UEVENT,
219 				 NULL, 0, 0, &disp->flip);
220 	}
221 
222 	nouveau_hw_save_vga_fonts(dev, 1);
223 
224 	nv04_crtc_create(dev, 0);
225 	if (nv_two_heads(dev))
226 		nv04_crtc_create(dev, 1);
227 
228 	for (i = 0; i < dcb->entries; i++) {
229 		struct dcb_output *dcbent = &dcb->entry[i];
230 
231 		connector = nouveau_connector_create(dev, dcbent);
232 		if (IS_ERR(connector))
233 			continue;
234 
235 		switch (dcbent->type) {
236 		case DCB_OUTPUT_ANALOG:
237 			ret = nv04_dac_create(connector, dcbent);
238 			break;
239 		case DCB_OUTPUT_LVDS:
240 		case DCB_OUTPUT_TMDS:
241 			ret = nv04_dfp_create(connector, dcbent);
242 			break;
243 		case DCB_OUTPUT_TV:
244 			if (dcbent->location == DCB_LOC_ON_CHIP)
245 				ret = nv17_tv_create(connector, dcbent);
246 			else
247 				ret = nv04_tv_create(connector, dcbent);
248 			break;
249 		default:
250 			NV_WARN(drm, "DCB type %d not known\n", dcbent->type);
251 			continue;
252 		}
253 
254 		if (ret)
255 			continue;
256 	}
257 
258 	list_for_each_entry_safe(connector, ct,
259 				 &dev->mode_config.connector_list, head) {
260 		if (!connector->encoder_ids[0]) {
261 			NV_WARN(drm, "%s has no encoders, removing\n",
262 				connector->name);
263 			connector->funcs->destroy(connector);
264 		}
265 	}
266 
267 	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
268 		struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
269 		struct nvkm_i2c_bus *bus =
270 			nvkm_i2c_bus_find(i2c, nv_encoder->dcb->i2c_index);
271 		nv_encoder->i2c = bus ? &bus->i2c : NULL;
272 	}
273 
274 	/* Save previous state */
275 	list_for_each_entry(crtc, &dev->mode_config.crtc_list, base.head)
276 		crtc->save(&crtc->base);
277 
278 	list_for_each_entry(nv_encoder, &dev->mode_config.encoder_list, base.base.head)
279 		nv_encoder->enc_save(&nv_encoder->base.base);
280 
281 	nouveau_overlay_init(dev);
282 
283 	return 0;
284 }
285