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

   1 /*
   2  * Copyright 2014 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 "outpdp.h"
  25 #include "conn.h"
  26 #include "dport.h"
  27 #include "priv.h"
  28
  29 #include <subdev/i2c.h>
  30
  31 #include <nvif/event.h>
  32
  33 int
  34 nvkm_output_dp_train(struct nvkm_output *base, u32 datarate, bool wait)
  35 {
  36         struct nvkm_output_dp *outp = nvkm_output_dp(base);
  37         bool retrain = true;
  38         u8 link[2], stat[3];
  39         u32 linkrate;
  40         int ret, i;
  41
  42         /* check that the link is trained at a high enough rate */
  43         ret = nvkm_rdaux(outp->aux, DPCD_LC00_LINK_BW_SET, link, 2);
  44         if (ret) {
  45                 OUTP_DBG(&outp->base,
  46                          "failed to read link config, assuming no sink");
  47                 goto done;
  48         }
  49
  50         linkrate = link[0] * 27000 * (link[1] & DPCD_LC01_LANE_COUNT_SET);
  51         linkrate = (linkrate * 8) / 10; /* 8B/10B coding overhead */
  52         datarate = (datarate + 9) / 10; /* -> decakilobits */
  53         if (linkrate < datarate) {
  54                 OUTP_DBG(&outp->base, "link not trained at sufficient rate");
  55                 goto done;
  56         }
  57
  58         /* check that link is still trained */
  59         ret = nvkm_rdaux(outp->aux, DPCD_LS02, stat, 3);
  60         if (ret) {
  61                 OUTP_DBG(&outp->base,
  62                          "failed to read link status, assuming no sink");
  63                 goto done;
  64         }
  65
  66         if (stat[2] & DPCD_LS04_INTERLANE_ALIGN_DONE) {
  67                 for (i = 0; i < (link[1] & DPCD_LC01_LANE_COUNT_SET); i++) {
  68                         u8 lane = (stat[i >> 1] >> ((i & 1) * 4)) & 0x0f;
  69                         if (!(lane & DPCD_LS02_LANE0_CR_DONE) ||
  70                             !(lane & DPCD_LS02_LANE0_CHANNEL_EQ_DONE) ||
  71                             !(lane & DPCD_LS02_LANE0_SYMBOL_LOCKED)) {
  72                                 OUTP_DBG(&outp->base,
  73                                          "lane %d not equalised", lane);
  74                                 goto done;
  75                         }
  76                 }
  77                 retrain = false;
  78         } else {
  79                 OUTP_DBG(&outp->base, "no inter-lane alignment");
  80         }
  81
  82 done:
  83         if (retrain || !atomic_read(&outp->lt.done)) {
  84                 /* no sink, but still need to configure source */
  85                 if (outp->dpcd[DPCD_RC00_DPCD_REV] == 0x00) {
  86                         outp->dpcd[DPCD_RC01_MAX_LINK_RATE] =
  87                                 outp->base.info.dpconf.link_bw;
  88                         outp->dpcd[DPCD_RC02] =
  89                                 outp->base.info.dpconf.link_nr;
  90                 }
  91                 atomic_set(&outp->lt.done, 0);
  92                 schedule_work(&outp->lt.work);
  93         } else {
  94                 nvkm_notify_get(&outp->irq);
  95         }
  96
  97         if (wait) {
  98                 if (!wait_event_timeout(outp->lt.wait,
  99                                         atomic_read(&outp->lt.done),
 100                                         msecs_to_jiffies(2000)))
 101                         ret = -ETIMEDOUT;
 102         }
 103
 104         return ret;
 105 }
 106
 107 static void
 108 nvkm_output_dp_enable(struct nvkm_output_dp *outp, bool enable)
 109 {
 110         struct nvkm_i2c_aux *aux = outp->aux;
 111
 112         if (enable) {
 113                 if (!outp->present) {
 114                         OUTP_DBG(&outp->base, "aux power -> always");
 115                         nvkm_i2c_aux_monitor(aux, true);
 116                         outp->present = true;
 117                 }
 118
 119                 if (!nvkm_rdaux(aux, DPCD_RC00_DPCD_REV, outp->dpcd,
 120                                 sizeof(outp->dpcd))) {
 121                         nvkm_output_dp_train(&outp->base, 0, true);
 122                         return;
 123                 }
 124         }
 125
 126         if (outp->present) {
 127                 OUTP_DBG(&outp->base, "aux power -> demand");
 128                 nvkm_i2c_aux_monitor(aux, false);
 129                 outp->present = false;
 130         }
 131
 132         atomic_set(&outp->lt.done, 0);
 133 }
 134
 135 static int
 136 nvkm_output_dp_hpd(struct nvkm_notify *notify)
 137 {
 138         const struct nvkm_i2c_ntfy_rep *line = notify->data;
 139         struct nvkm_output_dp *outp = container_of(notify, typeof(*outp), hpd);
 140         struct nvkm_connector *conn = outp->base.conn;
 141         struct nvkm_disp *disp = outp->base.disp;
 142         struct nvif_notify_conn_rep_v0 rep = {};
 143
 144         OUTP_DBG(&outp->base, "HPD: %d", line->mask);
 145         nvkm_output_dp_enable(outp, true);
 146
 147         if (line->mask & NVKM_I2C_UNPLUG)
 148                 rep.mask |= NVIF_NOTIFY_CONN_V0_UNPLUG;
 149         if (line->mask & NVKM_I2C_PLUG)
 150                 rep.mask |= NVIF_NOTIFY_CONN_V0_PLUG;
 151
 152         nvkm_event_send(&disp->hpd, rep.mask, conn->index, &rep, sizeof(rep));
 153         return NVKM_NOTIFY_KEEP;
 154 }
 155
 156 static int
 157 nvkm_output_dp_irq(struct nvkm_notify *notify)
 158 {
 159         const struct nvkm_i2c_ntfy_rep *line = notify->data;
 160         struct nvkm_output_dp *outp = container_of(notify, typeof(*outp), irq);
 161         struct nvkm_connector *conn = outp->base.conn;
 162         struct nvkm_disp *disp = outp->base.disp;
 163         struct nvif_notify_conn_rep_v0 rep = {
 164                 .mask = NVIF_NOTIFY_CONN_V0_IRQ,
 165         };
 166
 167         OUTP_DBG(&outp->base, "IRQ: %d", line->mask);
 168         nvkm_output_dp_train(&outp->base, 0, true);
 169
 170         nvkm_event_send(&disp->hpd, rep.mask, conn->index, &rep, sizeof(rep));
 171         return NVKM_NOTIFY_DROP;
 172 }
 173
 174 static void
 175 nvkm_output_dp_fini(struct nvkm_output *base)
 176 {
 177         struct nvkm_output_dp *outp = nvkm_output_dp(base);
 178         nvkm_notify_put(&outp->hpd);
 179         nvkm_notify_put(&outp->irq);
 180         flush_work(&outp->lt.work);
 181         nvkm_output_dp_enable(outp, false);
 182 }
 183
 184 static void
 185 nvkm_output_dp_init(struct nvkm_output *base)
 186 {
 187         struct nvkm_output_dp *outp = nvkm_output_dp(base);
 188         nvkm_notify_put(&outp->base.conn->hpd);
 189         nvkm_output_dp_enable(outp, true);
 190         nvkm_notify_get(&outp->hpd);
 191 }
 192
 193 static void *
 194 nvkm_output_dp_dtor(struct nvkm_output *base)
 195 {
 196         struct nvkm_output_dp *outp = nvkm_output_dp(base);
 197         nvkm_notify_fini(&outp->hpd);
 198         nvkm_notify_fini(&outp->irq);
 199         return outp;
 200 }
 201
 202 static const struct nvkm_output_func
 203 nvkm_output_dp_func = {
 204         .dtor = nvkm_output_dp_dtor,
 205         .init = nvkm_output_dp_init,
 206         .fini = nvkm_output_dp_fini,
 207 };
 208
 209 int
 210 nvkm_output_dp_ctor(const struct nvkm_output_dp_func *func,
 211                     struct nvkm_disp *disp, int index, struct dcb_output *dcbE,
 212                     struct nvkm_i2c_aux *aux, struct nvkm_output_dp *outp)
 213 {
 214         struct nvkm_device *device = disp->engine.subdev.device;
 215         struct nvkm_bios *bios = device->bios;
 216         struct nvkm_i2c *i2c = device->i2c;
 217         u8  hdr, cnt, len;
 218         u32 data;
 219         int ret;
 220
 221         nvkm_output_ctor(&nvkm_output_dp_func, disp, index, dcbE, &outp->base);
 222         outp->func = func;
 223         outp->aux = aux;
 224         if (!outp->aux) {
 225                 OUTP_ERR(&outp->base, "no aux");
 226                 return -ENODEV;
 227         }
 228
 229         /* bios data is not optional */
 230         data = nvbios_dpout_match(bios, outp->base.info.hasht,
 231                                   outp->base.info.hashm, &outp->version,
 232                                   &hdr, &cnt, &len, &outp->info);
 233         if (!data) {
 234                 OUTP_ERR(&outp->base, "no bios dp data");
 235                 return -ENODEV;
 236         }
 237
 238         OUTP_DBG(&outp->base, "bios dp %02x %02x %02x %02x",
 239                  outp->version, hdr, cnt, len);
 240
 241         /* link training */
 242         INIT_WORK(&outp->lt.work, nvkm_dp_train);
 243         init_waitqueue_head(&outp->lt.wait);
 244         atomic_set(&outp->lt.done, 0);
 245
 246         /* link maintenance */
 247         ret = nvkm_notify_init(NULL, &i2c->event, nvkm_output_dp_irq, true,
 248                                &(struct nvkm_i2c_ntfy_req) {
 249                                 .mask = NVKM_I2C_IRQ,
 250                                 .port = outp->aux->id,
 251                                },
 252                                sizeof(struct nvkm_i2c_ntfy_req),
 253                                sizeof(struct nvkm_i2c_ntfy_rep),
 254                                &outp->irq);
 255         if (ret) {
 256                 OUTP_ERR(&outp->base, "error monitoring aux irq: %d", ret);
 257                 return ret;
 258         }
 259
 260         /* hotplug detect, replaces gpio-based mechanism with aux events */
 261         ret = nvkm_notify_init(NULL, &i2c->event, nvkm_output_dp_hpd, true,
 262                                &(struct nvkm_i2c_ntfy_req) {
 263                                 .mask = NVKM_I2C_PLUG | NVKM_I2C_UNPLUG,
 264                                 .port = outp->aux->id,
 265                                },
 266                                sizeof(struct nvkm_i2c_ntfy_req),
 267                                sizeof(struct nvkm_i2c_ntfy_rep),
 268                                &outp->hpd);
 269         if (ret) {
 270                 OUTP_ERR(&outp->base, "error monitoring aux hpd: %d", ret);
 271                 return ret;
 272         }
 273
 274         return 0;
 275 }
 276
 277 int
 278 nvkm_output_dp_new_(const struct nvkm_output_dp_func *func,
 279                     struct nvkm_disp *disp, int index, struct dcb_output *dcbE,
 280                     struct nvkm_output **poutp)
 281 {
 282         struct nvkm_i2c *i2c = disp->engine.subdev.device->i2c;
 283         struct nvkm_i2c_aux *aux = nvkm_i2c_aux_find(i2c, dcbE->i2c_index);
 284         struct nvkm_output_dp *outp;
 285
 286         if (!(outp = kzalloc(sizeof(*outp), GFP_KERNEL)))
 287                 return -ENOMEM;
 288         *poutp = &outp->base;
 289
 290         return nvkm_output_dp_ctor(func, disp, index, dcbE, aux, outp);
 291 }