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