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 "conn.h" 26 #include "outp.h" 27 28 #include <core/client.h> 29 #include <core/notify.h> 30 #include <core/oproxy.h> 31 #include <subdev/bios.h> 32 #include <subdev/bios/dcb.h> 33 34 #include <nvif/class.h> 35 #include <nvif/cl0046.h> 36 #include <nvif/event.h> 37 #include <nvif/unpack.h> 38 39 static void 40 nvkm_disp_vblank_fini(struct nvkm_event *event, int type, int head) 41 { 42 struct nvkm_disp *disp = container_of(event, typeof(*disp), vblank); 43 disp->func->head.vblank_fini(disp, head); 44 } 45 46 static void 47 nvkm_disp_vblank_init(struct nvkm_event *event, int type, int head) 48 { 49 struct nvkm_disp *disp = container_of(event, typeof(*disp), vblank); 50 disp->func->head.vblank_init(disp, head); 51 } 52 53 static int 54 nvkm_disp_vblank_ctor(struct nvkm_object *object, void *data, u32 size, 55 struct nvkm_notify *notify) 56 { 57 struct nvkm_disp *disp = 58 container_of(notify->event, typeof(*disp), vblank); 59 union { 60 struct nvif_notify_head_req_v0 v0; 61 } *req = data; 62 int ret = -ENOSYS; 63 64 if (!(ret = nvif_unpack(ret, &data, &size, req->v0, 0, 0, false))) { 65 notify->size = sizeof(struct nvif_notify_head_rep_v0); 66 if (ret = -ENXIO, req->v0.head <= disp->vblank.index_nr) { 67 notify->types = 1; 68 notify->index = req->v0.head; 69 return 0; 70 } 71 } 72 73 return ret; 74 } 75 76 static const struct nvkm_event_func 77 nvkm_disp_vblank_func = { 78 .ctor = nvkm_disp_vblank_ctor, 79 .init = nvkm_disp_vblank_init, 80 .fini = nvkm_disp_vblank_fini, 81 }; 82 83 void 84 nvkm_disp_vblank(struct nvkm_disp *disp, int head) 85 { 86 struct nvif_notify_head_rep_v0 rep = {}; 87 nvkm_event_send(&disp->vblank, 1, head, &rep, sizeof(rep)); 88 } 89 90 static int 91 nvkm_disp_hpd_ctor(struct nvkm_object *object, void *data, u32 size, 92 struct nvkm_notify *notify) 93 { 94 struct nvkm_disp *disp = 95 container_of(notify->event, typeof(*disp), hpd); 96 union { 97 struct nvif_notify_conn_req_v0 v0; 98 } *req = data; 99 struct nvkm_output *outp; 100 int ret = -ENOSYS; 101 102 if (!(ret = nvif_unpack(ret, &data, &size, req->v0, 0, 0, false))) { 103 notify->size = sizeof(struct nvif_notify_conn_rep_v0); 104 list_for_each_entry(outp, &disp->outp, head) { 105 if (ret = -ENXIO, outp->conn->index == req->v0.conn) { 106 if (ret = -ENODEV, outp->conn->hpd.event) { 107 notify->types = req->v0.mask; 108 notify->index = req->v0.conn; 109 ret = 0; 110 } 111 break; 112 } 113 } 114 } 115 116 return ret; 117 } 118 119 static const struct nvkm_event_func 120 nvkm_disp_hpd_func = { 121 .ctor = nvkm_disp_hpd_ctor 122 }; 123 124 int 125 nvkm_disp_ntfy(struct nvkm_object *object, u32 type, struct nvkm_event **event) 126 { 127 struct nvkm_disp *disp = nvkm_disp(object->engine); 128 switch (type) { 129 case NV04_DISP_NTFY_VBLANK: 130 *event = &disp->vblank; 131 return 0; 132 case NV04_DISP_NTFY_CONN: 133 *event = &disp->hpd; 134 return 0; 135 default: 136 break; 137 } 138 return -EINVAL; 139 } 140 141 static void 142 nvkm_disp_class_del(struct nvkm_oproxy *oproxy) 143 { 144 struct nvkm_disp *disp = nvkm_disp(oproxy->base.engine); 145 mutex_lock(&disp->engine.subdev.mutex); 146 if (disp->client == oproxy) 147 disp->client = NULL; 148 mutex_unlock(&disp->engine.subdev.mutex); 149 } 150 151 static const struct nvkm_oproxy_func 152 nvkm_disp_class = { 153 .dtor[1] = nvkm_disp_class_del, 154 }; 155 156 static int 157 nvkm_disp_class_new(struct nvkm_device *device, 158 const struct nvkm_oclass *oclass, void *data, u32 size, 159 struct nvkm_object **pobject) 160 { 161 const struct nvkm_disp_oclass *sclass = oclass->engn; 162 struct nvkm_disp *disp = nvkm_disp(oclass->engine); 163 struct nvkm_oproxy *oproxy; 164 int ret; 165 166 ret = nvkm_oproxy_new_(&nvkm_disp_class, oclass, &oproxy); 167 if (ret) 168 return ret; 169 *pobject = &oproxy->base; 170 171 mutex_lock(&disp->engine.subdev.mutex); 172 if (disp->client) { 173 mutex_unlock(&disp->engine.subdev.mutex); 174 return -EBUSY; 175 } 176 disp->client = oproxy; 177 mutex_unlock(&disp->engine.subdev.mutex); 178 179 return sclass->ctor(disp, oclass, data, size, &oproxy->object); 180 } 181 182 static const struct nvkm_device_oclass 183 nvkm_disp_sclass = { 184 .ctor = nvkm_disp_class_new, 185 }; 186 187 static int 188 nvkm_disp_class_get(struct nvkm_oclass *oclass, int index, 189 const struct nvkm_device_oclass **class) 190 { 191 struct nvkm_disp *disp = nvkm_disp(oclass->engine); 192 if (index == 0) { 193 const struct nvkm_disp_oclass *root = disp->func->root(disp); 194 oclass->base = root->base; 195 oclass->engn = root; 196 *class = &nvkm_disp_sclass; 197 return 0; 198 } 199 return 1; 200 } 201 202 static void 203 nvkm_disp_intr(struct nvkm_engine *engine) 204 { 205 struct nvkm_disp *disp = nvkm_disp(engine); 206 disp->func->intr(disp); 207 } 208 209 static int 210 nvkm_disp_fini(struct nvkm_engine *engine, bool suspend) 211 { 212 struct nvkm_disp *disp = nvkm_disp(engine); 213 struct nvkm_connector *conn; 214 struct nvkm_output *outp; 215 216 list_for_each_entry(outp, &disp->outp, head) { 217 nvkm_output_fini(outp); 218 } 219 220 list_for_each_entry(conn, &disp->conn, head) { 221 nvkm_connector_fini(conn); 222 } 223 224 return 0; 225 } 226 227 static int 228 nvkm_disp_init(struct nvkm_engine *engine) 229 { 230 struct nvkm_disp *disp = nvkm_disp(engine); 231 struct nvkm_connector *conn; 232 struct nvkm_output *outp; 233 234 list_for_each_entry(conn, &disp->conn, head) { 235 nvkm_connector_init(conn); 236 } 237 238 list_for_each_entry(outp, &disp->outp, head) { 239 nvkm_output_init(outp); 240 } 241 242 return 0; 243 } 244 245 static void * 246 nvkm_disp_dtor(struct nvkm_engine *engine) 247 { 248 struct nvkm_disp *disp = nvkm_disp(engine); 249 struct nvkm_connector *conn; 250 struct nvkm_output *outp; 251 void *data = disp; 252 253 if (disp->func->dtor) 254 data = disp->func->dtor(disp); 255 256 nvkm_event_fini(&disp->vblank); 257 nvkm_event_fini(&disp->hpd); 258 259 while (!list_empty(&disp->outp)) { 260 outp = list_first_entry(&disp->outp, typeof(*outp), head); 261 list_del(&outp->head); 262 nvkm_output_del(&outp); 263 } 264 265 while (!list_empty(&disp->conn)) { 266 conn = list_first_entry(&disp->conn, typeof(*conn), head); 267 list_del(&conn->head); 268 nvkm_connector_del(&conn); 269 } 270 271 return data; 272 } 273 274 static const struct nvkm_engine_func 275 nvkm_disp = { 276 .dtor = nvkm_disp_dtor, 277 .init = nvkm_disp_init, 278 .fini = nvkm_disp_fini, 279 .intr = nvkm_disp_intr, 280 .base.sclass = nvkm_disp_class_get, 281 }; 282 283 int 284 nvkm_disp_ctor(const struct nvkm_disp_func *func, struct nvkm_device *device, 285 int index, int heads, struct nvkm_disp *disp) 286 { 287 struct nvkm_bios *bios = device->bios; 288 struct nvkm_output *outp, *outt, *pair; 289 struct nvkm_connector *conn; 290 struct nvbios_connE connE; 291 struct dcb_output dcbE; 292 u8 hpd = 0, ver, hdr; 293 u32 data; 294 int ret, i; 295 296 INIT_LIST_HEAD(&disp->outp); 297 INIT_LIST_HEAD(&disp->conn); 298 disp->func = func; 299 disp->head.nr = heads; 300 301 ret = nvkm_engine_ctor(&nvkm_disp, device, index, true, &disp->engine); 302 if (ret) 303 return ret; 304 305 /* create output objects for each display path in the vbios */ 306 i = -1; 307 while ((data = dcb_outp_parse(bios, ++i, &ver, &hdr, &dcbE))) { 308 const struct nvkm_disp_func_outp *outps; 309 int (*ctor)(struct nvkm_disp *, int, struct dcb_output *, 310 struct nvkm_output **); 311 312 if (dcbE.type == DCB_OUTPUT_UNUSED) 313 continue; 314 if (dcbE.type == DCB_OUTPUT_EOL) 315 break; 316 outp = NULL; 317 318 switch (dcbE.location) { 319 case 0: outps = &disp->func->outp.internal; break; 320 case 1: outps = &disp->func->outp.external; break; 321 default: 322 nvkm_warn(&disp->engine.subdev, 323 "dcb %d locn %d unknown\n", i, dcbE.location); 324 continue; 325 } 326 327 switch (dcbE.type) { 328 case DCB_OUTPUT_ANALOG: ctor = outps->crt ; break; 329 case DCB_OUTPUT_TV : ctor = outps->tv ; break; 330 case DCB_OUTPUT_TMDS : ctor = outps->tmds; break; 331 case DCB_OUTPUT_LVDS : ctor = outps->lvds; break; 332 case DCB_OUTPUT_DP : ctor = outps->dp ; break; 333 default: 334 nvkm_warn(&disp->engine.subdev, 335 "dcb %d type %d unknown\n", i, dcbE.type); 336 continue; 337 } 338 339 if (ctor) 340 ret = ctor(disp, i, &dcbE, &outp); 341 else 342 ret = -ENODEV; 343 344 if (ret) { 345 if (ret == -ENODEV) { 346 nvkm_debug(&disp->engine.subdev, 347 "dcb %d %d/%d not supported\n", 348 i, dcbE.location, dcbE.type); 349 continue; 350 } 351 nvkm_error(&disp->engine.subdev, 352 "failed to create output %d\n", i); 353 nvkm_output_del(&outp); 354 continue; 355 } 356 357 list_add_tail(&outp->head, &disp->outp); 358 hpd = max(hpd, (u8)(dcbE.connector + 1)); 359 } 360 361 /* create connector objects based on the outputs we support */ 362 list_for_each_entry_safe(outp, outt, &disp->outp, head) { 363 /* bios data *should* give us the most useful information */ 364 data = nvbios_connEp(bios, outp->info.connector, &ver, &hdr, 365 &connE); 366 367 /* no bios connector data... */ 368 if (!data) { 369 /* heuristic: anything with the same ccb index is 370 * considered to be on the same connector, any 371 * output path without an associated ccb entry will 372 * be put on its own connector 373 */ 374 int ccb_index = outp->info.i2c_index; 375 if (ccb_index != 0xf) { 376 list_for_each_entry(pair, &disp->outp, head) { 377 if (pair->info.i2c_index == ccb_index) { 378 outp->conn = pair->conn; 379 break; 380 } 381 } 382 } 383 384 /* connector shared with another output path */ 385 if (outp->conn) 386 continue; 387 388 memset(&connE, 0x00, sizeof(connE)); 389 connE.type = DCB_CONNECTOR_NONE; 390 i = -1; 391 } else { 392 i = outp->info.connector; 393 } 394 395 /* check that we haven't already created this connector */ 396 list_for_each_entry(conn, &disp->conn, head) { 397 if (conn->index == outp->info.connector) { 398 outp->conn = conn; 399 break; 400 } 401 } 402 403 if (outp->conn) 404 continue; 405 406 /* apparently we need to create a new one! */ 407 ret = nvkm_connector_new(disp, i, &connE, &outp->conn); 408 if (ret) { 409 nvkm_error(&disp->engine.subdev, 410 "failed to create output %d conn: %d\n", 411 outp->index, ret); 412 nvkm_connector_del(&outp->conn); 413 list_del(&outp->head); 414 nvkm_output_del(&outp); 415 continue; 416 } 417 418 list_add_tail(&outp->conn->head, &disp->conn); 419 } 420 421 ret = nvkm_event_init(&nvkm_disp_hpd_func, 3, hpd, &disp->hpd); 422 if (ret) 423 return ret; 424 425 ret = nvkm_event_init(&nvkm_disp_vblank_func, 1, heads, &disp->vblank); 426 if (ret) 427 return ret; 428 429 return 0; 430 } 431 432 int 433 nvkm_disp_new_(const struct nvkm_disp_func *func, struct nvkm_device *device, 434 int index, int heads, struct nvkm_disp **pdisp) 435 { 436 if (!(*pdisp = kzalloc(sizeof(**pdisp), GFP_KERNEL))) 437 return -ENOMEM; 438 return nvkm_disp_ctor(func, device, index, heads, *pdisp); 439 } 440