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 33int 34nvkm_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 82done: 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 107static void 108nvkm_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 135static int 136nvkm_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 156static int 157nvkm_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 174static void 175nvkm_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 184static void 185nvkm_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 193static void * 194nvkm_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 202static const struct nvkm_output_func 203nvkm_output_dp_func = { 204 .dtor = nvkm_output_dp_dtor, 205 .init = nvkm_output_dp_init, 206 .fini = nvkm_output_dp_fini, 207}; 208 209int 210nvkm_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 277int 278nvkm_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} 292