1 /*
2 * Copyright 2013 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 "priv.h"
25 #include "aux.h"
26 #include "bus.h"
27 #include "pad.h"
28
29 #include <core/option.h>
30 #include <subdev/bios.h>
31 #include <subdev/bios/dcb.h>
32 #include <subdev/bios/i2c.h>
33
34 static struct nvkm_i2c_pad *
nvkm_i2c_pad_find(struct nvkm_i2c * i2c,int id)35 nvkm_i2c_pad_find(struct nvkm_i2c *i2c, int id)
36 {
37 struct nvkm_i2c_pad *pad;
38
39 list_for_each_entry(pad, &i2c->pad, head) {
40 if (pad->id == id)
41 return pad;
42 }
43
44 return NULL;
45 }
46
47 struct nvkm_i2c_bus *
nvkm_i2c_bus_find(struct nvkm_i2c * i2c,int id)48 nvkm_i2c_bus_find(struct nvkm_i2c *i2c, int id)
49 {
50 struct nvkm_bios *bios = i2c->subdev.device->bios;
51 struct nvkm_i2c_bus *bus;
52
53 if (id == NVKM_I2C_BUS_PRI || id == NVKM_I2C_BUS_SEC) {
54 u8 ver, hdr, cnt, len;
55 u16 i2c = dcb_i2c_table(bios, &ver, &hdr, &cnt, &len);
56 if (i2c && ver >= 0x30) {
57 u8 auxidx = nvbios_rd08(bios, i2c + 4);
58 if (id == NVKM_I2C_BUS_PRI)
59 id = NVKM_I2C_BUS_CCB((auxidx & 0x0f) >> 0);
60 else
61 id = NVKM_I2C_BUS_CCB((auxidx & 0xf0) >> 4);
62 } else {
63 id = NVKM_I2C_BUS_CCB(2);
64 }
65 }
66
67 list_for_each_entry(bus, &i2c->bus, head) {
68 if (bus->id == id)
69 return bus;
70 }
71
72 return NULL;
73 }
74
75 struct nvkm_i2c_aux *
nvkm_i2c_aux_find(struct nvkm_i2c * i2c,int id)76 nvkm_i2c_aux_find(struct nvkm_i2c *i2c, int id)
77 {
78 struct nvkm_i2c_aux *aux;
79
80 list_for_each_entry(aux, &i2c->aux, head) {
81 if (aux->id == id)
82 return aux;
83 }
84
85 return NULL;
86 }
87
88 static void
nvkm_i2c_intr_fini(struct nvkm_event * event,int type,int id)89 nvkm_i2c_intr_fini(struct nvkm_event *event, int type, int id)
90 {
91 struct nvkm_i2c *i2c = container_of(event, typeof(*i2c), event);
92 struct nvkm_i2c_aux *aux = nvkm_i2c_aux_find(i2c, id);
93 if (aux)
94 i2c->func->aux_mask(i2c, type, aux->intr, 0);
95 }
96
97 static void
nvkm_i2c_intr_init(struct nvkm_event * event,int type,int id)98 nvkm_i2c_intr_init(struct nvkm_event *event, int type, int id)
99 {
100 struct nvkm_i2c *i2c = container_of(event, typeof(*i2c), event);
101 struct nvkm_i2c_aux *aux = nvkm_i2c_aux_find(i2c, id);
102 if (aux)
103 i2c->func->aux_mask(i2c, type, aux->intr, aux->intr);
104 }
105
106 static const struct nvkm_event_func
107 nvkm_i2c_intr_func = {
108 .init = nvkm_i2c_intr_init,
109 .fini = nvkm_i2c_intr_fini,
110 };
111
112 static void
nvkm_i2c_intr(struct nvkm_subdev * subdev)113 nvkm_i2c_intr(struct nvkm_subdev *subdev)
114 {
115 struct nvkm_i2c *i2c = nvkm_i2c(subdev);
116 struct nvkm_i2c_aux *aux;
117 u32 hi, lo, rq, tx;
118
119 if (!i2c->func->aux_stat)
120 return;
121
122 i2c->func->aux_stat(i2c, &hi, &lo, &rq, &tx);
123 if (!hi && !lo && !rq && !tx)
124 return;
125
126 list_for_each_entry(aux, &i2c->aux, head) {
127 u32 mask = 0;
128 if (hi & aux->intr) mask |= NVKM_I2C_PLUG;
129 if (lo & aux->intr) mask |= NVKM_I2C_UNPLUG;
130 if (rq & aux->intr) mask |= NVKM_I2C_IRQ;
131 if (tx & aux->intr) mask |= NVKM_I2C_DONE;
132 if (mask)
133 nvkm_event_ntfy(&i2c->event, aux->id, mask);
134 }
135 }
136
137 static int
nvkm_i2c_fini(struct nvkm_subdev * subdev,bool suspend)138 nvkm_i2c_fini(struct nvkm_subdev *subdev, bool suspend)
139 {
140 struct nvkm_i2c *i2c = nvkm_i2c(subdev);
141 struct nvkm_i2c_pad *pad;
142 struct nvkm_i2c_bus *bus;
143 struct nvkm_i2c_aux *aux;
144 u32 mask;
145
146 list_for_each_entry(aux, &i2c->aux, head) {
147 nvkm_i2c_aux_fini(aux);
148 }
149
150 list_for_each_entry(bus, &i2c->bus, head) {
151 nvkm_i2c_bus_fini(bus);
152 }
153
154 if ((mask = (1 << i2c->func->aux) - 1), i2c->func->aux_stat) {
155 i2c->func->aux_mask(i2c, NVKM_I2C_ANY, mask, 0);
156 i2c->func->aux_stat(i2c, &mask, &mask, &mask, &mask);
157 }
158
159 list_for_each_entry(pad, &i2c->pad, head) {
160 nvkm_i2c_pad_fini(pad);
161 }
162
163 return 0;
164 }
165
166 static int
nvkm_i2c_preinit(struct nvkm_subdev * subdev)167 nvkm_i2c_preinit(struct nvkm_subdev *subdev)
168 {
169 struct nvkm_i2c *i2c = nvkm_i2c(subdev);
170 struct nvkm_i2c_bus *bus;
171 struct nvkm_i2c_pad *pad;
172
173 /*
174 * We init our i2c busses as early as possible, since they may be
175 * needed by the vbios init scripts on some cards
176 */
177 list_for_each_entry(pad, &i2c->pad, head)
178 nvkm_i2c_pad_init(pad);
179 list_for_each_entry(bus, &i2c->bus, head)
180 nvkm_i2c_bus_init(bus);
181
182 return 0;
183 }
184
185 static int
nvkm_i2c_init(struct nvkm_subdev * subdev)186 nvkm_i2c_init(struct nvkm_subdev *subdev)
187 {
188 struct nvkm_i2c *i2c = nvkm_i2c(subdev);
189 struct nvkm_i2c_bus *bus;
190 struct nvkm_i2c_pad *pad;
191 struct nvkm_i2c_aux *aux;
192
193 list_for_each_entry(pad, &i2c->pad, head) {
194 nvkm_i2c_pad_init(pad);
195 }
196
197 list_for_each_entry(bus, &i2c->bus, head) {
198 nvkm_i2c_bus_init(bus);
199 }
200
201 list_for_each_entry(aux, &i2c->aux, head) {
202 nvkm_i2c_aux_init(aux);
203 }
204
205 return 0;
206 }
207
208 static void *
nvkm_i2c_dtor(struct nvkm_subdev * subdev)209 nvkm_i2c_dtor(struct nvkm_subdev *subdev)
210 {
211 struct nvkm_i2c *i2c = nvkm_i2c(subdev);
212
213 nvkm_event_fini(&i2c->event);
214
215 while (!list_empty(&i2c->aux)) {
216 struct nvkm_i2c_aux *aux =
217 list_first_entry(&i2c->aux, typeof(*aux), head);
218 nvkm_i2c_aux_del(&aux);
219 }
220
221 while (!list_empty(&i2c->bus)) {
222 struct nvkm_i2c_bus *bus =
223 list_first_entry(&i2c->bus, typeof(*bus), head);
224 nvkm_i2c_bus_del(&bus);
225 }
226
227 while (!list_empty(&i2c->pad)) {
228 struct nvkm_i2c_pad *pad =
229 list_first_entry(&i2c->pad, typeof(*pad), head);
230 nvkm_i2c_pad_del(&pad);
231 }
232
233 return i2c;
234 }
235
236 static const struct nvkm_subdev_func
237 nvkm_i2c = {
238 .dtor = nvkm_i2c_dtor,
239 .preinit = nvkm_i2c_preinit,
240 .init = nvkm_i2c_init,
241 .fini = nvkm_i2c_fini,
242 .intr = nvkm_i2c_intr,
243 };
244
245 static const struct nvkm_i2c_drv {
246 u8 bios;
247 u8 addr;
248 int (*pad_new)(struct nvkm_i2c_bus *, int id, u8 addr,
249 struct nvkm_i2c_pad **);
250 }
251 nvkm_i2c_drv[] = {
252 { 0x0d, 0x39, anx9805_pad_new },
253 { 0x0e, 0x3b, anx9805_pad_new },
254 {}
255 };
256
257 int
nvkm_i2c_new_(const struct nvkm_i2c_func * func,struct nvkm_device * device,enum nvkm_subdev_type type,int inst,struct nvkm_i2c ** pi2c)258 nvkm_i2c_new_(const struct nvkm_i2c_func *func, struct nvkm_device *device,
259 enum nvkm_subdev_type type, int inst, struct nvkm_i2c **pi2c)
260 {
261 struct nvkm_bios *bios = device->bios;
262 struct nvkm_i2c *i2c;
263 struct dcb_i2c_entry ccbE;
264 struct dcb_output dcbE;
265 u8 ver, hdr;
266 int ret, i;
267
268 if (!(i2c = *pi2c = kzalloc(sizeof(*i2c), GFP_KERNEL)))
269 return -ENOMEM;
270
271 nvkm_subdev_ctor(&nvkm_i2c, device, type, inst, &i2c->subdev);
272 i2c->func = func;
273 INIT_LIST_HEAD(&i2c->pad);
274 INIT_LIST_HEAD(&i2c->bus);
275 INIT_LIST_HEAD(&i2c->aux);
276
277 i = -1;
278 while (!dcb_i2c_parse(bios, ++i, &ccbE)) {
279 struct nvkm_i2c_pad *pad = NULL;
280 struct nvkm_i2c_bus *bus = NULL;
281 struct nvkm_i2c_aux *aux = NULL;
282
283 nvkm_debug(&i2c->subdev, "ccb %02x: type %02x drive %02x "
284 "sense %02x share %02x auxch %02x\n", i, ccbE.type,
285 ccbE.drive, ccbE.sense, ccbE.share, ccbE.auxch);
286
287 if (ccbE.share != DCB_I2C_UNUSED) {
288 const int id = NVKM_I2C_PAD_HYBRID(ccbE.share);
289 if (!(pad = nvkm_i2c_pad_find(i2c, id)))
290 ret = func->pad_s_new(i2c, id, &pad);
291 else
292 ret = 0;
293 } else {
294 ret = func->pad_x_new(i2c, NVKM_I2C_PAD_CCB(i), &pad);
295 }
296
297 if (ret) {
298 nvkm_error(&i2c->subdev, "ccb %02x pad, %d\n", i, ret);
299 nvkm_i2c_pad_del(&pad);
300 continue;
301 }
302
303 if (pad->func->bus_new_0 && ccbE.type == DCB_I2C_NV04_BIT) {
304 ret = pad->func->bus_new_0(pad, NVKM_I2C_BUS_CCB(i),
305 ccbE.drive,
306 ccbE.sense, &bus);
307 } else
308 if (pad->func->bus_new_4 &&
309 ( ccbE.type == DCB_I2C_NV4E_BIT ||
310 ccbE.type == DCB_I2C_NVIO_BIT ||
311 (ccbE.type == DCB_I2C_PMGR &&
312 ccbE.drive != DCB_I2C_UNUSED))) {
313 ret = pad->func->bus_new_4(pad, NVKM_I2C_BUS_CCB(i),
314 ccbE.drive, &bus);
315 }
316
317 if (ret) {
318 nvkm_error(&i2c->subdev, "ccb %02x bus, %d\n", i, ret);
319 nvkm_i2c_bus_del(&bus);
320 }
321
322 if (pad->func->aux_new_6 &&
323 ( ccbE.type == DCB_I2C_NVIO_AUX ||
324 (ccbE.type == DCB_I2C_PMGR &&
325 ccbE.auxch != DCB_I2C_UNUSED))) {
326 ret = pad->func->aux_new_6(pad, NVKM_I2C_BUS_CCB(i),
327 ccbE.auxch, &aux);
328 } else {
329 ret = 0;
330 }
331
332 if (ret) {
333 nvkm_error(&i2c->subdev, "ccb %02x aux, %d\n", i, ret);
334 nvkm_i2c_aux_del(&aux);
335 }
336
337 if (ccbE.type != DCB_I2C_UNUSED && !bus && !aux) {
338 nvkm_warn(&i2c->subdev, "ccb %02x was ignored\n", i);
339 continue;
340 }
341 }
342
343 i = -1;
344 while (dcb_outp_parse(bios, ++i, &ver, &hdr, &dcbE)) {
345 const struct nvkm_i2c_drv *drv = nvkm_i2c_drv;
346 struct nvkm_i2c_bus *bus;
347 struct nvkm_i2c_pad *pad;
348
349 /* internal outputs handled by native i2c busses (above) */
350 if (!dcbE.location)
351 continue;
352
353 /* we need an i2c bus to talk to the external encoder */
354 bus = nvkm_i2c_bus_find(i2c, dcbE.i2c_index);
355 if (!bus) {
356 nvkm_debug(&i2c->subdev, "dcb %02x no bus\n", i);
357 continue;
358 }
359
360 /* ... and a driver for it */
361 while (drv->pad_new) {
362 if (drv->bios == dcbE.extdev)
363 break;
364 drv++;
365 }
366
367 if (!drv->pad_new) {
368 nvkm_debug(&i2c->subdev, "dcb %02x drv %02x unknown\n",
369 i, dcbE.extdev);
370 continue;
371 }
372
373 /* find/create an instance of the driver */
374 pad = nvkm_i2c_pad_find(i2c, NVKM_I2C_PAD_EXT(dcbE.extdev));
375 if (!pad) {
376 const int id = NVKM_I2C_PAD_EXT(dcbE.extdev);
377 ret = drv->pad_new(bus, id, drv->addr, &pad);
378 if (ret) {
379 nvkm_error(&i2c->subdev, "dcb %02x pad, %d\n",
380 i, ret);
381 nvkm_i2c_pad_del(&pad);
382 continue;
383 }
384 }
385
386 /* create any i2c bus / aux channel required by the output */
387 if (pad->func->aux_new_6 && dcbE.type == DCB_OUTPUT_DP) {
388 const int id = NVKM_I2C_AUX_EXT(dcbE.extdev);
389 struct nvkm_i2c_aux *aux = NULL;
390 ret = pad->func->aux_new_6(pad, id, 0, &aux);
391 if (ret) {
392 nvkm_error(&i2c->subdev, "dcb %02x aux, %d\n",
393 i, ret);
394 nvkm_i2c_aux_del(&aux);
395 }
396 } else
397 if (pad->func->bus_new_4) {
398 const int id = NVKM_I2C_BUS_EXT(dcbE.extdev);
399 struct nvkm_i2c_bus *bus = NULL;
400 ret = pad->func->bus_new_4(pad, id, 0, &bus);
401 if (ret) {
402 nvkm_error(&i2c->subdev, "dcb %02x bus, %d\n",
403 i, ret);
404 nvkm_i2c_bus_del(&bus);
405 }
406 }
407 }
408
409 return nvkm_event_init(&nvkm_i2c_intr_func, &i2c->subdev, 4, i, &i2c->event);
410 }
411