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 * 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 * 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 * 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 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 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 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 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 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 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 * 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 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