1 /*
2  * Copyright 2014 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  * Authors: Ben Skeggs
23  */
24 #include "outp.h"
25 #include "dp.h"
26 #include "ior.h"
27 
28 #include <subdev/bios.h>
29 #include <subdev/bios/dcb.h>
30 #include <subdev/i2c.h>
31 
32 void
33 nvkm_outp_route(struct nvkm_disp *disp)
34 {
35 	struct nvkm_outp *outp;
36 	struct nvkm_ior *ior;
37 
38 	list_for_each_entry(ior, &disp->ior, head) {
39 		if ((outp = ior->arm.outp) && ior->arm.outp != ior->asy.outp) {
40 			OUTP_DBG(outp, "release %s", ior->name);
41 			if (ior->func->route.set)
42 				ior->func->route.set(outp, NULL);
43 			ior->arm.outp = NULL;
44 		}
45 	}
46 
47 	list_for_each_entry(ior, &disp->ior, head) {
48 		if ((outp = ior->asy.outp)) {
49 			OUTP_DBG(outp, "acquire %s", ior->name);
50 			if (ior->asy.outp != ior->arm.outp) {
51 				if (ior->func->route.set)
52 					ior->func->route.set(outp, ior);
53 				ior->arm.outp = ior->asy.outp;
54 			}
55 		}
56 	}
57 }
58 
59 static enum nvkm_ior_proto
60 nvkm_outp_xlat(struct nvkm_outp *outp, enum nvkm_ior_type *type)
61 {
62 	switch (outp->info.location) {
63 	case 0:
64 		switch (outp->info.type) {
65 		case DCB_OUTPUT_ANALOG: *type = DAC; return  CRT;
66 		case DCB_OUTPUT_TV    : *type = DAC; return   TV;
67 		case DCB_OUTPUT_TMDS  : *type = SOR; return TMDS;
68 		case DCB_OUTPUT_LVDS  : *type = SOR; return LVDS;
69 		case DCB_OUTPUT_DP    : *type = SOR; return   DP;
70 		default:
71 			break;
72 		}
73 		break;
74 	case 1:
75 		switch (outp->info.type) {
76 		case DCB_OUTPUT_TMDS: *type = PIOR; return TMDS;
77 		case DCB_OUTPUT_DP  : *type = PIOR; return TMDS; /* not a bug */
78 		default:
79 			break;
80 		}
81 		break;
82 	default:
83 		break;
84 	}
85 	WARN_ON(1);
86 	return UNKNOWN;
87 }
88 
89 void
90 nvkm_outp_release(struct nvkm_outp *outp, u8 user)
91 {
92 	struct nvkm_ior *ior = outp->ior;
93 	OUTP_TRACE(outp, "release %02x &= %02x %p", outp->acquired, ~user, ior);
94 	if (ior) {
95 		outp->acquired &= ~user;
96 		if (!outp->acquired) {
97 			if (outp->func->release && outp->ior)
98 				outp->func->release(outp);
99 			outp->ior->asy.outp = NULL;
100 			outp->ior = NULL;
101 		}
102 	}
103 }
104 
105 static inline int
106 nvkm_outp_acquire_ior(struct nvkm_outp *outp, u8 user, struct nvkm_ior *ior)
107 {
108 	outp->ior = ior;
109 	outp->ior->asy.outp = outp;
110 	outp->ior->asy.link = outp->info.sorconf.link;
111 	outp->acquired |= user;
112 	return 0;
113 }
114 
115 static inline int
116 nvkm_outp_acquire_hda(struct nvkm_outp *outp, enum nvkm_ior_type type,
117 		      u8 user, bool hda)
118 {
119 	struct nvkm_ior *ior;
120 
121 	/* Failing that, a completely unused OR is the next best thing. */
122 	list_for_each_entry(ior, &outp->disp->ior, head) {
123 		if (!ior->identity && !!ior->func->hda.hpd == hda &&
124 		    !ior->asy.outp && ior->type == type && !ior->arm.outp &&
125 		    (ior->func->route.set || ior->id == __ffs(outp->info.or)))
126 			return nvkm_outp_acquire_ior(outp, user, ior);
127 	}
128 
129 	/* Last resort is to assign an OR that's already active on HW,
130 	 * but will be released during the next modeset.
131 	 */
132 	list_for_each_entry(ior, &outp->disp->ior, head) {
133 		if (!ior->identity && !!ior->func->hda.hpd == hda &&
134 		    !ior->asy.outp && ior->type == type &&
135 		    (ior->func->route.set || ior->id == __ffs(outp->info.or)))
136 			return nvkm_outp_acquire_ior(outp, user, ior);
137 	}
138 
139 	return -ENOSPC;
140 }
141 
142 int
143 nvkm_outp_acquire(struct nvkm_outp *outp, u8 user, bool hda)
144 {
145 	struct nvkm_ior *ior = outp->ior;
146 	enum nvkm_ior_proto proto;
147 	enum nvkm_ior_type type;
148 
149 	OUTP_TRACE(outp, "acquire %02x |= %02x %p", outp->acquired, user, ior);
150 	if (ior) {
151 		outp->acquired |= user;
152 		return 0;
153 	}
154 
155 	/* Lookup a compatible, and unused, OR to assign to the device. */
156 	proto = nvkm_outp_xlat(outp, &type);
157 	if (proto == UNKNOWN)
158 		return -ENOSYS;
159 
160 	/* Deal with panels requiring identity-mapped SOR assignment. */
161 	if (outp->identity) {
162 		ior = nvkm_ior_find(outp->disp, SOR, ffs(outp->info.or) - 1);
163 		if (WARN_ON(!ior))
164 			return -ENOSPC;
165 		return nvkm_outp_acquire_ior(outp, user, ior);
166 	}
167 
168 	/* First preference is to reuse the OR that is currently armed
169 	 * on HW, if any, in order to prevent unnecessary switching.
170 	 */
171 	list_for_each_entry(ior, &outp->disp->ior, head) {
172 		if (!ior->identity && !ior->asy.outp && ior->arm.outp == outp) {
173 			/*XXX: For various complicated reasons, we can't outright switch
174 			 *     the boot-time OR on the first modeset without some fairly
175 			 *     invasive changes.
176 			 *
177 			 *     The systems that were fixed by modifying the OR selection
178 			 *     code to account for HDA support shouldn't regress here as
179 			 *     the HDA-enabled ORs match the relevant output's pad macro
180 			 *     index, and the firmware seems to select an OR this way.
181 			 *
182 			 *     This warning is to make it obvious if that proves wrong.
183 			 */
184 			WARN_ON(hda && !ior->func->hda.hpd);
185 			return nvkm_outp_acquire_ior(outp, user, ior);
186 		}
187 	}
188 
189 	/* If we don't need HDA, first try to acquire an OR that doesn't
190 	 * support it to leave free the ones that do.
191 	 */
192 	if (!hda) {
193 		if (!nvkm_outp_acquire_hda(outp, type, user, false))
194 			return 0;
195 
196 		/* Use a HDA-supporting SOR anyway. */
197 		return nvkm_outp_acquire_hda(outp, type, user, true);
198 	}
199 
200 	/* We want HDA, try to acquire an OR that supports it. */
201 	if (!nvkm_outp_acquire_hda(outp, type, user, true))
202 		return 0;
203 
204 	/* There weren't any free ORs that support HDA, grab one that
205 	 * doesn't and at least allow display to work still.
206 	 */
207 	return nvkm_outp_acquire_hda(outp, type, user, false);
208 }
209 
210 void
211 nvkm_outp_fini(struct nvkm_outp *outp)
212 {
213 	if (outp->func->fini)
214 		outp->func->fini(outp);
215 }
216 
217 static void
218 nvkm_outp_init_route(struct nvkm_outp *outp)
219 {
220 	struct nvkm_disp *disp = outp->disp;
221 	enum nvkm_ior_proto proto;
222 	enum nvkm_ior_type type;
223 	struct nvkm_ior *ior;
224 	int id, link;
225 
226 	/* Find any OR from the class that is able to support this device. */
227 	proto = nvkm_outp_xlat(outp, &type);
228 	if (proto == UNKNOWN)
229 		return;
230 
231 	ior = nvkm_ior_find(disp, type, -1);
232 	if (!ior) {
233 		WARN_ON(1);
234 		return;
235 	}
236 
237 	/* Determine the specific OR, if any, this device is attached to. */
238 	if (ior->func->route.get) {
239 		id = ior->func->route.get(outp, &link);
240 		if (id < 0) {
241 			OUTP_DBG(outp, "no route");
242 			return;
243 		}
244 	} else {
245 		/* Prior to DCB 4.1, this is hardwired like so. */
246 		id   = ffs(outp->info.or) - 1;
247 		link = (ior->type == SOR) ? outp->info.sorconf.link : 0;
248 	}
249 
250 	ior = nvkm_ior_find(disp, type, id);
251 	if (!ior) {
252 		WARN_ON(1);
253 		return;
254 	}
255 
256 	/* Determine if the OR is already configured for this device. */
257 	ior->func->state(ior, &ior->arm);
258 	if (!ior->arm.head || ior->arm.proto != proto) {
259 		OUTP_DBG(outp, "no heads (%x %d %d)", ior->arm.head,
260 			 ior->arm.proto, proto);
261 
262 		/* The EFI GOP driver on Ampere can leave unused DP links routed,
263 		 * which we don't expect.  The DisableLT IED script *should* get
264 		 * us back to where we need to be.
265 		 */
266 		if (ior->func->route.get && !ior->arm.head && outp->info.type == DCB_OUTPUT_DP)
267 			nvkm_dp_disable(outp, ior);
268 
269 		return;
270 	}
271 
272 	OUTP_DBG(outp, "on %s link %x", ior->name, ior->arm.link);
273 	ior->arm.outp = outp;
274 }
275 
276 void
277 nvkm_outp_init(struct nvkm_outp *outp)
278 {
279 	nvkm_outp_init_route(outp);
280 	if (outp->func->init)
281 		outp->func->init(outp);
282 }
283 
284 void
285 nvkm_outp_del(struct nvkm_outp **poutp)
286 {
287 	struct nvkm_outp *outp = *poutp;
288 	if (outp && !WARN_ON(!outp->func)) {
289 		if (outp->func->dtor)
290 			*poutp = outp->func->dtor(outp);
291 		kfree(*poutp);
292 		*poutp = NULL;
293 	}
294 }
295 
296 int
297 nvkm_outp_ctor(const struct nvkm_outp_func *func, struct nvkm_disp *disp,
298 	       int index, struct dcb_output *dcbE, struct nvkm_outp *outp)
299 {
300 	struct nvkm_i2c *i2c = disp->engine.subdev.device->i2c;
301 	enum nvkm_ior_proto proto;
302 	enum nvkm_ior_type type;
303 
304 	outp->func = func;
305 	outp->disp = disp;
306 	outp->index = index;
307 	outp->info = *dcbE;
308 	outp->i2c = nvkm_i2c_bus_find(i2c, dcbE->i2c_index);
309 
310 	OUTP_DBG(outp, "type %02x loc %d or %d link %d con %x "
311 		       "edid %x bus %d head %x",
312 		 outp->info.type, outp->info.location, outp->info.or,
313 		 outp->info.type >= 2 ? outp->info.sorconf.link : 0,
314 		 outp->info.connector, outp->info.i2c_index,
315 		 outp->info.bus, outp->info.heads);
316 
317 	/* Cull output paths we can't map to an output resource. */
318 	proto = nvkm_outp_xlat(outp, &type);
319 	if (proto == UNKNOWN)
320 		return -ENODEV;
321 
322 	return 0;
323 }
324 
325 static const struct nvkm_outp_func
326 nvkm_outp = {
327 };
328 
329 int
330 nvkm_outp_new(struct nvkm_disp *disp, int index, struct dcb_output *dcbE,
331 	      struct nvkm_outp **poutp)
332 {
333 	if (!(*poutp = kzalloc(sizeof(**poutp), GFP_KERNEL)))
334 		return -ENOMEM;
335 	return nvkm_outp_ctor(&nvkm_outp, disp, index, dcbE, *poutp);
336 }
337