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_drm.h"
29#include "nouveau_reg.h"
30#include "hw.h"
31#include "nouveau_encoder.h"
32#include "nouveau_connector.h"
33
34int
35nv04_display_create(struct drm_device *dev)
36{
37	struct nouveau_drm *drm = nouveau_drm(dev);
38	struct nvkm_i2c *i2c = nvxx_i2c(&drm->device);
39	struct dcb_table *dcb = &drm->vbios.dcb;
40	struct drm_connector *connector, *ct;
41	struct drm_encoder *encoder;
42	struct drm_crtc *crtc;
43	struct nv04_display *disp;
44	int i, ret;
45
46	disp = kzalloc(sizeof(*disp), GFP_KERNEL);
47	if (!disp)
48		return -ENOMEM;
49
50	nvif_object_map(nvif_object(&drm->device));
51
52	nouveau_display(dev)->priv = disp;
53	nouveau_display(dev)->dtor = nv04_display_destroy;
54	nouveau_display(dev)->init = nv04_display_init;
55	nouveau_display(dev)->fini = nv04_display_fini;
56
57	nouveau_hw_save_vga_fonts(dev, 1);
58
59	nv04_crtc_create(dev, 0);
60	if (nv_two_heads(dev))
61		nv04_crtc_create(dev, 1);
62
63	for (i = 0; i < dcb->entries; i++) {
64		struct dcb_output *dcbent = &dcb->entry[i];
65
66		connector = nouveau_connector_create(dev, dcbent->connector);
67		if (IS_ERR(connector))
68			continue;
69
70		switch (dcbent->type) {
71		case DCB_OUTPUT_ANALOG:
72			ret = nv04_dac_create(connector, dcbent);
73			break;
74		case DCB_OUTPUT_LVDS:
75		case DCB_OUTPUT_TMDS:
76			ret = nv04_dfp_create(connector, dcbent);
77			break;
78		case DCB_OUTPUT_TV:
79			if (dcbent->location == DCB_LOC_ON_CHIP)
80				ret = nv17_tv_create(connector, dcbent);
81			else
82				ret = nv04_tv_create(connector, dcbent);
83			break;
84		default:
85			NV_WARN(drm, "DCB type %d not known\n", dcbent->type);
86			continue;
87		}
88
89		if (ret)
90			continue;
91	}
92
93	list_for_each_entry_safe(connector, ct,
94				 &dev->mode_config.connector_list, head) {
95		if (!connector->encoder_ids[0]) {
96			NV_WARN(drm, "%s has no encoders, removing\n",
97				connector->name);
98			connector->funcs->destroy(connector);
99		}
100	}
101
102	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
103		struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
104		nv_encoder->i2c = i2c->find(i2c, nv_encoder->dcb->i2c_index);
105	}
106
107	/* Save previous state */
108	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
109		crtc->funcs->save(crtc);
110
111	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
112		const struct drm_encoder_helper_funcs *func = encoder->helper_private;
113
114		func->save(encoder);
115	}
116
117	nouveau_overlay_init(dev);
118
119	return 0;
120}
121
122void
123nv04_display_destroy(struct drm_device *dev)
124{
125	struct nv04_display *disp = nv04_display(dev);
126	struct nouveau_drm *drm = nouveau_drm(dev);
127	struct drm_encoder *encoder;
128	struct drm_crtc *crtc;
129
130	/* Turn every CRTC off. */
131	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
132		struct drm_mode_set modeset = {
133			.crtc = crtc,
134		};
135
136		drm_mode_set_config_internal(&modeset);
137	}
138
139	/* Restore state */
140	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
141		const struct drm_encoder_helper_funcs *func = encoder->helper_private;
142
143		func->restore(encoder);
144	}
145
146	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
147		crtc->funcs->restore(crtc);
148
149	nouveau_hw_save_vga_fonts(dev, 0);
150
151	nouveau_display(dev)->priv = NULL;
152	kfree(disp);
153
154	nvif_object_unmap(nvif_object(&drm->device));
155}
156
157int
158nv04_display_init(struct drm_device *dev)
159{
160	struct drm_encoder *encoder;
161	struct drm_crtc *crtc;
162
163	/* meh.. modeset apparently doesn't setup all the regs and depends
164	 * on pre-existing state, for now load the state of the card *before*
165	 * nouveau was loaded, and then do a modeset.
166	 *
167	 * best thing to do probably is to make save/restore routines not
168	 * save/restore "pre-load" state, but more general so we can save
169	 * on suspend too.
170	 */
171	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
172		const struct drm_encoder_helper_funcs *func = encoder->helper_private;
173
174		func->restore(encoder);
175	}
176
177	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
178		crtc->funcs->restore(crtc);
179
180	return 0;
181}
182
183void
184nv04_display_fini(struct drm_device *dev)
185{
186	/* disable vblank interrupts */
187	NVWriteCRTC(dev, 0, NV_PCRTC_INTR_EN_0, 0);
188	if (nv_two_heads(dev))
189		NVWriteCRTC(dev, 1, NV_PCRTC_INTR_EN_0, 0);
190}
191