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
34 int
nv04_display_create(struct drm_device * dev)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->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
122 void
nv04_display_destroy(struct drm_device * dev)123 nv04_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
157 int
nv04_display_init(struct drm_device * dev)158 nv04_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
183 void
nv04_display_fini(struct drm_device * dev)184 nv04_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