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/notify.h>
  29 #include <subdev/bios.h>
  30 #include <subdev/bios/dcb.h>
  31
  32 #include <nvif/class.h>
  33 #include <nvif/event.h>
  34 #include <nvif/unpack.h>
  35
  36 int
  37 nvkm_disp_vblank_ctor(struct nvkm_object *object, void *data, u32 size,
  38                       struct nvkm_notify *notify)
  39 {
  40         struct nvkm_disp *disp =
  41                 container_of(notify->event, typeof(*disp), vblank);
  42         union {
  43                 struct nvif_notify_head_req_v0 v0;
  44         } *req = data;
  45         int ret;
  46
  47         if (nvif_unpack(req->v0, 0, 0, false)) {
  48                 notify->size = sizeof(struct nvif_notify_head_rep_v0);
  49                 if (ret = -ENXIO, req->v0.head <= disp->vblank.index_nr) {
  50                         notify->types = 1;
  51                         notify->index = req->v0.head;
  52                         return 0;
  53                 }
  54         }
  55
  56         return ret;
  57 }
  58
  59 void
  60 nvkm_disp_vblank(struct nvkm_disp *disp, int head)
  61 {
  62         struct nvif_notify_head_rep_v0 rep = {};
  63         nvkm_event_send(&disp->vblank, 1, head, &rep, sizeof(rep));
  64 }
  65
  66 static int
  67 nvkm_disp_hpd_ctor(struct nvkm_object *object, void *data, u32 size,
  68                    struct nvkm_notify *notify)
  69 {
  70         struct nvkm_disp *disp =
  71                 container_of(notify->event, typeof(*disp), hpd);
  72         union {
  73                 struct nvif_notify_conn_req_v0 v0;
  74         } *req = data;
  75         struct nvkm_output *outp;
  76         int ret;
  77
  78         if (nvif_unpack(req->v0, 0, 0, false)) {
  79                 notify->size = sizeof(struct nvif_notify_conn_rep_v0);
  80                 list_for_each_entry(outp, &disp->outp, head) {
  81                         if (ret = -ENXIO, outp->conn->index == req->v0.conn) {
  82                                 if (ret = -ENODEV, outp->conn->hpd.event) {
  83                                         notify->types = req->v0.mask;
  84                                         notify->index = req->v0.conn;
  85                                         ret = 0;
  86                                 }
  87                                 break;
  88                         }
  89                 }
  90         }
  91
  92         return ret;
  93 }
  94
  95 static const struct nvkm_event_func
  96 nvkm_disp_hpd_func = {
  97         .ctor = nvkm_disp_hpd_ctor
  98 };
  99
 100 int
 101 nvkm_disp_ntfy(struct nvkm_object *object, u32 type, struct nvkm_event **event)
 102 {
 103         struct nvkm_disp *disp = (void *)object->engine;
 104         switch (type) {
 105         case NV04_DISP_NTFY_VBLANK:
 106                 *event = &disp->vblank;
 107                 return 0;
 108         case NV04_DISP_NTFY_CONN:
 109                 *event = &disp->hpd;
 110                 return 0;
 111         default:
 112                 break;
 113         }
 114         return -EINVAL;
 115 }
 116
 117 int
 118 _nvkm_disp_fini(struct nvkm_object *object, bool suspend)
 119 {
 120         struct nvkm_disp *disp = (void *)object;
 121         struct nvkm_output *outp;
 122         int ret;
 123
 124         list_for_each_entry(outp, &disp->outp, head) {
 125                 ret = nv_ofuncs(outp)->fini(nv_object(outp), suspend);
 126                 if (ret && suspend)
 127                         goto fail_outp;
 128         }
 129
 130         return nvkm_engine_fini(&disp->base, suspend);
 131
 132 fail_outp:
 133         list_for_each_entry_continue_reverse(outp, &disp->outp, head) {
 134                 nv_ofuncs(outp)->init(nv_object(outp));
 135         }
 136
 137         return ret;
 138 }
 139
 140 int
 141 _nvkm_disp_init(struct nvkm_object *object)
 142 {
 143         struct nvkm_disp *disp = (void *)object;
 144         struct nvkm_output *outp;
 145         int ret;
 146
 147         ret = nvkm_engine_init(&disp->base);
 148         if (ret)
 149                 return ret;
 150
 151         list_for_each_entry(outp, &disp->outp, head) {
 152                 ret = nv_ofuncs(outp)->init(nv_object(outp));
 153                 if (ret)
 154                         goto fail_outp;
 155         }
 156
 157         return ret;
 158
 159 fail_outp:
 160         list_for_each_entry_continue_reverse(outp, &disp->outp, head) {
 161                 nv_ofuncs(outp)->fini(nv_object(outp), false);
 162         }
 163
 164         return ret;
 165 }
 166
 167 void
 168 _nvkm_disp_dtor(struct nvkm_object *object)
 169 {
 170         struct nvkm_disp *disp = (void *)object;
 171         struct nvkm_output *outp, *outt;
 172
 173         nvkm_event_fini(&disp->vblank);
 174         nvkm_event_fini(&disp->hpd);
 175
 176         if (disp->outp.next) {
 177                 list_for_each_entry_safe(outp, outt, &disp->outp, head) {
 178                         nvkm_object_ref(NULL, (struct nvkm_object **)&outp);
 179                 }
 180         }
 181
 182         nvkm_engine_destroy(&disp->base);
 183 }
 184
 185 int
 186 nvkm_disp_create_(struct nvkm_object *parent, struct nvkm_object *engine,
 187                   struct nvkm_oclass *oclass, int heads, const char *intname,
 188                   const char *extname, int length, void **pobject)
 189 {
 190         struct nvkm_disp_impl *impl = (void *)oclass;
 191         struct nvkm_bios *bios = nvkm_bios(parent);
 192         struct nvkm_disp *disp;
 193         struct nvkm_oclass **sclass;
 194         struct nvkm_object *object;
 195         struct dcb_output dcbE;
 196         u8  hpd = 0, ver, hdr;
 197         u32 data;
 198         int ret, i;
 199
 200         ret = nvkm_engine_create_(parent, engine, oclass, true, intname,
 201                                   extname, length, pobject);
 202         disp = *pobject;
 203         if (ret)
 204                 return ret;
 205
 206         INIT_LIST_HEAD(&disp->outp);
 207
 208         /* create output objects for each display path in the vbios */
 209         i = -1;
 210         while ((data = dcb_outp_parse(bios, ++i, &ver, &hdr, &dcbE))) {
 211                 if (dcbE.type == DCB_OUTPUT_UNUSED)
 212                         continue;
 213                 if (dcbE.type == DCB_OUTPUT_EOL)
 214                         break;
 215                 data = dcbE.location << 4 | dcbE.type;
 216
 217                 oclass = nvkm_output_oclass;
 218                 sclass = impl->outp;
 219                 while (sclass && sclass[0]) {
 220                         if (sclass[0]->handle == data) {
 221                                 oclass = sclass[0];
 222                                 break;
 223                         }
 224                         sclass++;
 225                 }
 226
 227                 nvkm_object_ctor(*pobject, NULL, oclass, &dcbE, i, &object);
 228                 hpd = max(hpd, (u8)(dcbE.connector + 1));
 229         }
 230
 231         ret = nvkm_event_init(&nvkm_disp_hpd_func, 3, hpd, &disp->hpd);
 232         if (ret)
 233                 return ret;
 234
 235         ret = nvkm_event_init(impl->vblank, 1, heads, &disp->vblank);
 236         if (ret)
 237                 return ret;
 238
 239         return 0;
 240 }