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