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