kernel/drivers/gpu/drm/nouveau/nvkm/engine/disp/base.c

   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/event.h>
  36 #include <nvif/unpack.h>
  37
  38 static void
  39 nvkm_disp_vblank_fini(struct nvkm_event *event, int type, int head)
  40 {
  41         struct nvkm_disp *disp = container_of(event, typeof(*disp), vblank);
  42         disp->func->head.vblank_fini(disp, head);
  43 }
  44
  45 static void
  46 nvkm_disp_vblank_init(struct nvkm_event *event, int type, int head)
  47 {
  48         struct nvkm_disp *disp = container_of(event, typeof(*disp), vblank);
  49         disp->func->head.vblank_init(disp, head);
  50 }
  51
  52 static int
  53 nvkm_disp_vblank_ctor(struct nvkm_object *object, void *data, u32 size,
  54                       struct nvkm_notify *notify)
  55 {
  56         struct nvkm_disp *disp =
  57                 container_of(notify->event, typeof(*disp), vblank);
  58         union {
  59                 struct nvif_notify_head_req_v0 v0;
  60         } *req = data;
  61         int ret;
  62
  63         if (nvif_unpack(req->v0, 0, 0, false)) {
  64                 notify->size = sizeof(struct nvif_notify_head_rep_v0);
  65                 if (ret = -ENXIO, req->v0.head <= disp->vblank.index_nr) {
  66                         notify->types = 1;
  67                         notify->index = req->v0.head;
  68                         return 0;
  69                 }
  70         }
  71
  72         return ret;
  73 }
  74
  75 static const struct nvkm_event_func
  76 nvkm_disp_vblank_func = {
  77         .ctor = nvkm_disp_vblank_ctor,
  78         .init = nvkm_disp_vblank_init,
  79         .fini = nvkm_disp_vblank_fini,
  80 };
  81
  82 void
  83 nvkm_disp_vblank(struct nvkm_disp *disp, int head)
  84 {
  85         struct nvif_notify_head_rep_v0 rep = {};
  86         nvkm_event_send(&disp->vblank, 1, head, &rep, sizeof(rep));
  87 }
  88
  89 static int
  90 nvkm_disp_hpd_ctor(struct nvkm_object *object, void *data, u32 size,
  91                    struct nvkm_notify *notify)
  92 {
  93         struct nvkm_disp *disp =
  94                 container_of(notify->event, typeof(*disp), hpd);
  95         union {
  96                 struct nvif_notify_conn_req_v0 v0;
  97         } *req = data;
  98         struct nvkm_output *outp;
  99         int ret;
 100
 101         if (nvif_unpack(req->v0, 0, 0, false)) {
 102                 notify->size = sizeof(struct nvif_notify_conn_rep_v0);
 103                 list_for_each_entry(outp, &disp->outp, head) {
 104                         if (ret = -ENXIO, outp->conn->index == req->v0.conn) {
 105                                 if (ret = -ENODEV, outp->conn->hpd.event) {
 106                                         notify->types = req->v0.mask;
 107                                         notify->index = req->v0.conn;
 108                                         ret = 0;
 109                                 }
 110                                 break;
 111                         }
 112                 }
 113         }
 114
 115         return ret;
 116 }
 117
 118 static const struct nvkm_event_func
 119 nvkm_disp_hpd_func = {
 120         .ctor = nvkm_disp_hpd_ctor
 121 };
 122
 123 int
 124 nvkm_disp_ntfy(struct nvkm_object *object, u32 type, struct nvkm_event **event)
 125 {
 126         struct nvkm_disp *disp = nvkm_disp(object->engine);
 127         switch (type) {
 128         case NV04_DISP_NTFY_VBLANK:
 129                 *event = &disp->vblank;
 130                 return 0;
 131         case NV04_DISP_NTFY_CONN:
 132                 *event = &disp->hpd;
 133                 return 0;
 134         default:
 135                 break;
 136         }
 137         return -EINVAL;
 138 }
 139
 140 static void
 141 nvkm_disp_class_del(struct nvkm_oproxy *oproxy)
 142 {
 143         struct nvkm_disp *disp = nvkm_disp(oproxy->base.engine);
 144         mutex_lock(&disp->engine.subdev.mutex);
 145         if (disp->client == oproxy)
 146                 disp->client = NULL;
 147         mutex_unlock(&disp->engine.subdev.mutex);
 148 }
 149
 150 static const struct nvkm_oproxy_func
 151 nvkm_disp_class = {
 152         .dtor[1] = nvkm_disp_class_del,
 153 };
 154
 155 static int
 156 nvkm_disp_class_new(struct nvkm_device *device,
 157                     const struct nvkm_oclass *oclass, void *data, u32 size,
 158                     struct nvkm_object **pobject)
 159 {
 160         const struct nvkm_disp_oclass *sclass = oclass->engn;
 161         struct nvkm_disp *disp = nvkm_disp(oclass->engine);
 162         struct nvkm_oproxy *oproxy;
 163         int ret;
 164
 165         ret = nvkm_oproxy_new_(&nvkm_disp_class, oclass, &oproxy);
 166         if (ret)
 167                 return ret;
 168         *pobject = &oproxy->base;
 169
 170         mutex_lock(&disp->engine.subdev.mutex);
 171         if (disp->client) {
 172                 mutex_unlock(&disp->engine.subdev.mutex);
 173                 return -EBUSY;
 174         }
 175         disp->client = oproxy;
 176         mutex_unlock(&disp->engine.subdev.mutex);
 177
 178         return sclass->ctor(disp, oclass, data, size, &oproxy->object);
 179 }
 180
 181 static const struct nvkm_device_oclass
 182 nvkm_disp_sclass = {
 183         .ctor = nvkm_disp_class_new,
 184 };
 185
 186 static int
 187 nvkm_disp_class_get(struct nvkm_oclass *oclass, int index,
 188                     const struct nvkm_device_oclass **class)
 189 {
 190         struct nvkm_disp *disp = nvkm_disp(oclass->engine);
 191         if (index == 0) {
 192                 const struct nvkm_disp_oclass *root = disp->func->root(disp);
 193                 oclass->base = root->base;
 194                 oclass->engn = root;
 195                 *class = &nvkm_disp_sclass;
 196                 return 0;
 197         }
 198         return 1;
 199 }
 200
 201 static void
 202 nvkm_disp_intr(struct nvkm_engine *engine)
 203 {
 204         struct nvkm_disp *disp = nvkm_disp(engine);
 205         disp->func->intr(disp);
 206 }
 207
 208 static int
 209 nvkm_disp_fini(struct nvkm_engine *engine, bool suspend)
 210 {
 211         struct nvkm_disp *disp = nvkm_disp(engine);
 212         struct nvkm_connector *conn;
 213         struct nvkm_output *outp;
 214
 215         list_for_each_entry(outp, &disp->outp, head) {
 216                 nvkm_output_fini(outp);
 217         }
 218
 219         list_for_each_entry(conn, &disp->conn, head) {
 220                 nvkm_connector_fini(conn);
 221         }
 222
 223         return 0;
 224 }
 225
 226 static int
 227 nvkm_disp_init(struct nvkm_engine *engine)
 228 {
 229         struct nvkm_disp *disp = nvkm_disp(engine);
 230         struct nvkm_connector *conn;
 231         struct nvkm_output *outp;
 232
 233         list_for_each_entry(conn, &disp->conn, head) {
 234                 nvkm_connector_init(conn);
 235         }
 236
 237         list_for_each_entry(outp, &disp->outp, head) {
 238                 nvkm_output_init(outp);
 239         }
 240
 241         return 0;
 242 }
 243
 244 static void *
 245 nvkm_disp_dtor(struct nvkm_engine *engine)
 246 {
 247         struct nvkm_disp *disp = nvkm_disp(engine);
 248         struct nvkm_connector *conn;
 249         struct nvkm_output *outp;
 250         void *data = disp;
 251
 252         if (disp->func->dtor)
 253                 data = disp->func->dtor(disp);
 254
 255         nvkm_event_fini(&disp->vblank);
 256         nvkm_event_fini(&disp->hpd);
 257
 258         while (!list_empty(&disp->outp)) {
 259                 outp = list_first_entry(&disp->outp, typeof(*outp), head);
 260                 list_del(&outp->head);
 261                 nvkm_output_del(&outp);
 262         }
 263
 264         while (!list_empty(&disp->conn)) {
 265                 conn = list_first_entry(&disp->conn, typeof(*conn), head);
 266                 list_del(&conn->head);
 267                 nvkm_connector_del(&conn);
 268         }
 269
 270         return data;
 271 }
 272
 273 static const struct nvkm_engine_func
 274 nvkm_disp = {
 275         .dtor = nvkm_disp_dtor,
 276         .init = nvkm_disp_init,
 277         .fini = nvkm_disp_fini,
 278         .intr = nvkm_disp_intr,
 279         .base.sclass = nvkm_disp_class_get,
 280 };
 281
 282 int
 283 nvkm_disp_ctor(const struct nvkm_disp_func *func, struct nvkm_device *device,
 284                int index, int heads, struct nvkm_disp *disp)
 285 {
 286         struct nvkm_bios *bios = device->bios;
 287         struct nvkm_output *outp, *outt, *pair;
 288         struct nvkm_connector *conn;
 289         struct nvbios_connE connE;
 290         struct dcb_output dcbE;
 291         u8  hpd = 0, ver, hdr;
 292         u32 data;
 293         int ret, i;
 294
 295         INIT_LIST_HEAD(&disp->outp);
 296         INIT_LIST_HEAD(&disp->conn);
 297         disp->func = func;
 298         disp->head.nr = heads;
 299
 300         ret = nvkm_engine_ctor(&nvkm_disp, device, index, 0,
 301                                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 }