1 /*
2  * Copyright © 2014 Red Hat
3  *
4  * Permission to use, copy, modify, distribute, and sell this software and its
5  * documentation for any purpose is hereby granted without fee, provided that
6  * the above copyright notice appear in all copies and that both that copyright
7  * notice and this permission notice appear in supporting documentation, and
8  * that the name of the copyright holders not be used in advertising or
9  * publicity pertaining to distribution of the software without specific,
10  * written prior permission.  The copyright holders make no representations
11  * about the suitability of this software for any purpose.  It is provided "as
12  * is" without express or implied warranty.
13  *
14  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
15  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
16  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
17  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
18  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
19  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
20  * OF THIS SOFTWARE.
21  */
22 
23 #include <linux/kernel.h>
24 #include <linux/delay.h>
25 #include <linux/init.h>
26 #include <linux/errno.h>
27 #include <linux/sched.h>
28 #include <linux/seq_file.h>
29 #include <linux/i2c.h>
30 #include <drm/drm_dp_mst_helper.h>
31 #include <drm/drmP.h>
32 
33 #include <drm/drm_fixed.h>
34 
35 /**
36  * DOC: dp mst helper
37  *
38  * These functions contain parts of the DisplayPort 1.2a MultiStream Transport
39  * protocol. The helpers contain a topology manager and bandwidth manager.
40  * The helpers encapsulate the sending and received of sideband msgs.
41  */
42 static bool dump_dp_payload_table(struct drm_dp_mst_topology_mgr *mgr,
43 				  char *buf);
44 static int test_calc_pbn_mode(void);
45 
46 static void drm_dp_put_port(struct drm_dp_mst_port *port);
47 
48 static int drm_dp_dpcd_write_payload(struct drm_dp_mst_topology_mgr *mgr,
49 				     int id,
50 				     struct drm_dp_payload *payload);
51 
52 static int drm_dp_send_dpcd_write(struct drm_dp_mst_topology_mgr *mgr,
53 				  struct drm_dp_mst_port *port,
54 				  int offset, int size, u8 *bytes);
55 
56 static void drm_dp_send_link_address(struct drm_dp_mst_topology_mgr *mgr,
57 				     struct drm_dp_mst_branch *mstb);
58 static int drm_dp_send_enum_path_resources(struct drm_dp_mst_topology_mgr *mgr,
59 					   struct drm_dp_mst_branch *mstb,
60 					   struct drm_dp_mst_port *port);
61 static bool drm_dp_validate_guid(struct drm_dp_mst_topology_mgr *mgr,
62 				 u8 *guid);
63 
64 static int drm_dp_mst_register_i2c_bus(struct drm_dp_aux *aux);
65 static void drm_dp_mst_unregister_i2c_bus(struct drm_dp_aux *aux);
66 static void drm_dp_mst_kick_tx(struct drm_dp_mst_topology_mgr *mgr);
67 /* sideband msg handling */
drm_dp_msg_header_crc4(const uint8_t * data,size_t num_nibbles)68 static u8 drm_dp_msg_header_crc4(const uint8_t *data, size_t num_nibbles)
69 {
70 	u8 bitmask = 0x80;
71 	u8 bitshift = 7;
72 	u8 array_index = 0;
73 	int number_of_bits = num_nibbles * 4;
74 	u8 remainder = 0;
75 
76 	while (number_of_bits != 0) {
77 		number_of_bits--;
78 		remainder <<= 1;
79 		remainder |= (data[array_index] & bitmask) >> bitshift;
80 		bitmask >>= 1;
81 		bitshift--;
82 		if (bitmask == 0) {
83 			bitmask = 0x80;
84 			bitshift = 7;
85 			array_index++;
86 		}
87 		if ((remainder & 0x10) == 0x10)
88 			remainder ^= 0x13;
89 	}
90 
91 	number_of_bits = 4;
92 	while (number_of_bits != 0) {
93 		number_of_bits--;
94 		remainder <<= 1;
95 		if ((remainder & 0x10) != 0)
96 			remainder ^= 0x13;
97 	}
98 
99 	return remainder;
100 }
101 
drm_dp_msg_data_crc4(const uint8_t * data,u8 number_of_bytes)102 static u8 drm_dp_msg_data_crc4(const uint8_t *data, u8 number_of_bytes)
103 {
104 	u8 bitmask = 0x80;
105 	u8 bitshift = 7;
106 	u8 array_index = 0;
107 	int number_of_bits = number_of_bytes * 8;
108 	u16 remainder = 0;
109 
110 	while (number_of_bits != 0) {
111 		number_of_bits--;
112 		remainder <<= 1;
113 		remainder |= (data[array_index] & bitmask) >> bitshift;
114 		bitmask >>= 1;
115 		bitshift--;
116 		if (bitmask == 0) {
117 			bitmask = 0x80;
118 			bitshift = 7;
119 			array_index++;
120 		}
121 		if ((remainder & 0x100) == 0x100)
122 			remainder ^= 0xd5;
123 	}
124 
125 	number_of_bits = 8;
126 	while (number_of_bits != 0) {
127 		number_of_bits--;
128 		remainder <<= 1;
129 		if ((remainder & 0x100) != 0)
130 			remainder ^= 0xd5;
131 	}
132 
133 	return remainder & 0xff;
134 }
drm_dp_calc_sb_hdr_size(struct drm_dp_sideband_msg_hdr * hdr)135 static inline u8 drm_dp_calc_sb_hdr_size(struct drm_dp_sideband_msg_hdr *hdr)
136 {
137 	u8 size = 3;
138 	size += (hdr->lct / 2);
139 	return size;
140 }
141 
drm_dp_encode_sideband_msg_hdr(struct drm_dp_sideband_msg_hdr * hdr,u8 * buf,int * len)142 static void drm_dp_encode_sideband_msg_hdr(struct drm_dp_sideband_msg_hdr *hdr,
143 					   u8 *buf, int *len)
144 {
145 	int idx = 0;
146 	int i;
147 	u8 crc4;
148 	buf[idx++] = ((hdr->lct & 0xf) << 4) | (hdr->lcr & 0xf);
149 	for (i = 0; i < (hdr->lct / 2); i++)
150 		buf[idx++] = hdr->rad[i];
151 	buf[idx++] = (hdr->broadcast << 7) | (hdr->path_msg << 6) |
152 		(hdr->msg_len & 0x3f);
153 	buf[idx++] = (hdr->somt << 7) | (hdr->eomt << 6) | (hdr->seqno << 4);
154 
155 	crc4 = drm_dp_msg_header_crc4(buf, (idx * 2) - 1);
156 	buf[idx - 1] |= (crc4 & 0xf);
157 
158 	*len = idx;
159 }
160 
drm_dp_decode_sideband_msg_hdr(struct drm_dp_sideband_msg_hdr * hdr,u8 * buf,int buflen,u8 * hdrlen)161 static bool drm_dp_decode_sideband_msg_hdr(struct drm_dp_sideband_msg_hdr *hdr,
162 					   u8 *buf, int buflen, u8 *hdrlen)
163 {
164 	u8 crc4;
165 	u8 len;
166 	int i;
167 	u8 idx;
168 	if (buf[0] == 0)
169 		return false;
170 	len = 3;
171 	len += ((buf[0] & 0xf0) >> 4) / 2;
172 	if (len > buflen)
173 		return false;
174 	crc4 = drm_dp_msg_header_crc4(buf, (len * 2) - 1);
175 
176 	if ((crc4 & 0xf) != (buf[len - 1] & 0xf)) {
177 		DRM_DEBUG_KMS("crc4 mismatch 0x%x 0x%x\n", crc4, buf[len - 1]);
178 		return false;
179 	}
180 
181 	hdr->lct = (buf[0] & 0xf0) >> 4;
182 	hdr->lcr = (buf[0] & 0xf);
183 	idx = 1;
184 	for (i = 0; i < (hdr->lct / 2); i++)
185 		hdr->rad[i] = buf[idx++];
186 	hdr->broadcast = (buf[idx] >> 7) & 0x1;
187 	hdr->path_msg = (buf[idx] >> 6) & 0x1;
188 	hdr->msg_len = buf[idx] & 0x3f;
189 	idx++;
190 	hdr->somt = (buf[idx] >> 7) & 0x1;
191 	hdr->eomt = (buf[idx] >> 6) & 0x1;
192 	hdr->seqno = (buf[idx] >> 4) & 0x1;
193 	idx++;
194 	*hdrlen = idx;
195 	return true;
196 }
197 
drm_dp_encode_sideband_req(struct drm_dp_sideband_msg_req_body * req,struct drm_dp_sideband_msg_tx * raw)198 static void drm_dp_encode_sideband_req(struct drm_dp_sideband_msg_req_body *req,
199 				       struct drm_dp_sideband_msg_tx *raw)
200 {
201 	int idx = 0;
202 	int i;
203 	u8 *buf = raw->msg;
204 	buf[idx++] = req->req_type & 0x7f;
205 
206 	switch (req->req_type) {
207 	case DP_ENUM_PATH_RESOURCES:
208 		buf[idx] = (req->u.port_num.port_number & 0xf) << 4;
209 		idx++;
210 		break;
211 	case DP_ALLOCATE_PAYLOAD:
212 		buf[idx] = (req->u.allocate_payload.port_number & 0xf) << 4 |
213 			(req->u.allocate_payload.number_sdp_streams & 0xf);
214 		idx++;
215 		buf[idx] = (req->u.allocate_payload.vcpi & 0x7f);
216 		idx++;
217 		buf[idx] = (req->u.allocate_payload.pbn >> 8);
218 		idx++;
219 		buf[idx] = (req->u.allocate_payload.pbn & 0xff);
220 		idx++;
221 		for (i = 0; i < req->u.allocate_payload.number_sdp_streams / 2; i++) {
222 			buf[idx] = ((req->u.allocate_payload.sdp_stream_sink[i * 2] & 0xf) << 4) |
223 				(req->u.allocate_payload.sdp_stream_sink[i * 2 + 1] & 0xf);
224 			idx++;
225 		}
226 		if (req->u.allocate_payload.number_sdp_streams & 1) {
227 			i = req->u.allocate_payload.number_sdp_streams - 1;
228 			buf[idx] = (req->u.allocate_payload.sdp_stream_sink[i] & 0xf) << 4;
229 			idx++;
230 		}
231 		break;
232 	case DP_QUERY_PAYLOAD:
233 		buf[idx] = (req->u.query_payload.port_number & 0xf) << 4;
234 		idx++;
235 		buf[idx] = (req->u.query_payload.vcpi & 0x7f);
236 		idx++;
237 		break;
238 	case DP_REMOTE_DPCD_READ:
239 		buf[idx] = (req->u.dpcd_read.port_number & 0xf) << 4;
240 		buf[idx] |= ((req->u.dpcd_read.dpcd_address & 0xf0000) >> 16) & 0xf;
241 		idx++;
242 		buf[idx] = (req->u.dpcd_read.dpcd_address & 0xff00) >> 8;
243 		idx++;
244 		buf[idx] = (req->u.dpcd_read.dpcd_address & 0xff);
245 		idx++;
246 		buf[idx] = (req->u.dpcd_read.num_bytes);
247 		idx++;
248 		break;
249 
250 	case DP_REMOTE_DPCD_WRITE:
251 		buf[idx] = (req->u.dpcd_write.port_number & 0xf) << 4;
252 		buf[idx] |= ((req->u.dpcd_write.dpcd_address & 0xf0000) >> 16) & 0xf;
253 		idx++;
254 		buf[idx] = (req->u.dpcd_write.dpcd_address & 0xff00) >> 8;
255 		idx++;
256 		buf[idx] = (req->u.dpcd_write.dpcd_address & 0xff);
257 		idx++;
258 		buf[idx] = (req->u.dpcd_write.num_bytes);
259 		idx++;
260 		memcpy(&buf[idx], req->u.dpcd_write.bytes, req->u.dpcd_write.num_bytes);
261 		idx += req->u.dpcd_write.num_bytes;
262 		break;
263 	case DP_REMOTE_I2C_READ:
264 		buf[idx] = (req->u.i2c_read.port_number & 0xf) << 4;
265 		buf[idx] |= (req->u.i2c_read.num_transactions & 0x3);
266 		idx++;
267 		for (i = 0; i < (req->u.i2c_read.num_transactions & 0x3); i++) {
268 			buf[idx] = req->u.i2c_read.transactions[i].i2c_dev_id & 0x7f;
269 			idx++;
270 			buf[idx] = req->u.i2c_read.transactions[i].num_bytes;
271 			idx++;
272 			memcpy(&buf[idx], req->u.i2c_read.transactions[i].bytes, req->u.i2c_read.transactions[i].num_bytes);
273 			idx += req->u.i2c_read.transactions[i].num_bytes;
274 
275 			buf[idx] = (req->u.i2c_read.transactions[i].no_stop_bit & 0x1) << 5;
276 			buf[idx] |= (req->u.i2c_read.transactions[i].i2c_transaction_delay & 0xf);
277 			idx++;
278 		}
279 		buf[idx] = (req->u.i2c_read.read_i2c_device_id) & 0x7f;
280 		idx++;
281 		buf[idx] = (req->u.i2c_read.num_bytes_read);
282 		idx++;
283 		break;
284 
285 	case DP_REMOTE_I2C_WRITE:
286 		buf[idx] = (req->u.i2c_write.port_number & 0xf) << 4;
287 		idx++;
288 		buf[idx] = (req->u.i2c_write.write_i2c_device_id) & 0x7f;
289 		idx++;
290 		buf[idx] = (req->u.i2c_write.num_bytes);
291 		idx++;
292 		memcpy(&buf[idx], req->u.i2c_write.bytes, req->u.i2c_write.num_bytes);
293 		idx += req->u.i2c_write.num_bytes;
294 		break;
295 	}
296 	raw->cur_len = idx;
297 }
298 
drm_dp_crc_sideband_chunk_req(u8 * msg,u8 len)299 static void drm_dp_crc_sideband_chunk_req(u8 *msg, u8 len)
300 {
301 	u8 crc4;
302 	crc4 = drm_dp_msg_data_crc4(msg, len);
303 	msg[len] = crc4;
304 }
305 
drm_dp_encode_sideband_reply(struct drm_dp_sideband_msg_reply_body * rep,struct drm_dp_sideband_msg_tx * raw)306 static void drm_dp_encode_sideband_reply(struct drm_dp_sideband_msg_reply_body *rep,
307 					 struct drm_dp_sideband_msg_tx *raw)
308 {
309 	int idx = 0;
310 	u8 *buf = raw->msg;
311 
312 	buf[idx++] = (rep->reply_type & 0x1) << 7 | (rep->req_type & 0x7f);
313 
314 	raw->cur_len = idx;
315 }
316 
317 /* this adds a chunk of msg to the builder to get the final msg */
drm_dp_sideband_msg_build(struct drm_dp_sideband_msg_rx * msg,u8 * replybuf,u8 replybuflen,bool hdr)318 static bool drm_dp_sideband_msg_build(struct drm_dp_sideband_msg_rx *msg,
319 				      u8 *replybuf, u8 replybuflen, bool hdr)
320 {
321 	int ret;
322 	u8 crc4;
323 
324 	if (hdr) {
325 		u8 hdrlen;
326 		struct drm_dp_sideband_msg_hdr recv_hdr;
327 		ret = drm_dp_decode_sideband_msg_hdr(&recv_hdr, replybuf, replybuflen, &hdrlen);
328 		if (ret == false) {
329 			print_hex_dump(KERN_DEBUG, "failed hdr", DUMP_PREFIX_NONE, 16, 1, replybuf, replybuflen, false);
330 			return false;
331 		}
332 
333 		/* get length contained in this portion */
334 		msg->curchunk_len = recv_hdr.msg_len;
335 		msg->curchunk_hdrlen = hdrlen;
336 
337 		/* we have already gotten an somt - don't bother parsing */
338 		if (recv_hdr.somt && msg->have_somt)
339 			return false;
340 
341 		if (recv_hdr.somt) {
342 			memcpy(&msg->initial_hdr, &recv_hdr, sizeof(struct drm_dp_sideband_msg_hdr));
343 			msg->have_somt = true;
344 		}
345 		if (recv_hdr.eomt)
346 			msg->have_eomt = true;
347 
348 		/* copy the bytes for the remainder of this header chunk */
349 		msg->curchunk_idx = min(msg->curchunk_len, (u8)(replybuflen - hdrlen));
350 		memcpy(&msg->chunk[0], replybuf + hdrlen, msg->curchunk_idx);
351 	} else {
352 		memcpy(&msg->chunk[msg->curchunk_idx], replybuf, replybuflen);
353 		msg->curchunk_idx += replybuflen;
354 	}
355 
356 	if (msg->curchunk_idx >= msg->curchunk_len) {
357 		/* do CRC */
358 		crc4 = drm_dp_msg_data_crc4(msg->chunk, msg->curchunk_len - 1);
359 		/* copy chunk into bigger msg */
360 		memcpy(&msg->msg[msg->curlen], msg->chunk, msg->curchunk_len - 1);
361 		msg->curlen += msg->curchunk_len - 1;
362 	}
363 	return true;
364 }
365 
drm_dp_sideband_parse_link_address(struct drm_dp_sideband_msg_rx * raw,struct drm_dp_sideband_msg_reply_body * repmsg)366 static bool drm_dp_sideband_parse_link_address(struct drm_dp_sideband_msg_rx *raw,
367 					       struct drm_dp_sideband_msg_reply_body *repmsg)
368 {
369 	int idx = 1;
370 	int i;
371 	memcpy(repmsg->u.link_addr.guid, &raw->msg[idx], 16);
372 	idx += 16;
373 	repmsg->u.link_addr.nports = raw->msg[idx] & 0xf;
374 	idx++;
375 	if (idx > raw->curlen)
376 		goto fail_len;
377 	for (i = 0; i < repmsg->u.link_addr.nports; i++) {
378 		if (raw->msg[idx] & 0x80)
379 			repmsg->u.link_addr.ports[i].input_port = 1;
380 
381 		repmsg->u.link_addr.ports[i].peer_device_type = (raw->msg[idx] >> 4) & 0x7;
382 		repmsg->u.link_addr.ports[i].port_number = (raw->msg[idx] & 0xf);
383 
384 		idx++;
385 		if (idx > raw->curlen)
386 			goto fail_len;
387 		repmsg->u.link_addr.ports[i].mcs = (raw->msg[idx] >> 7) & 0x1;
388 		repmsg->u.link_addr.ports[i].ddps = (raw->msg[idx] >> 6) & 0x1;
389 		if (repmsg->u.link_addr.ports[i].input_port == 0)
390 			repmsg->u.link_addr.ports[i].legacy_device_plug_status = (raw->msg[idx] >> 5) & 0x1;
391 		idx++;
392 		if (idx > raw->curlen)
393 			goto fail_len;
394 		if (repmsg->u.link_addr.ports[i].input_port == 0) {
395 			repmsg->u.link_addr.ports[i].dpcd_revision = (raw->msg[idx]);
396 			idx++;
397 			if (idx > raw->curlen)
398 				goto fail_len;
399 			memcpy(repmsg->u.link_addr.ports[i].peer_guid, &raw->msg[idx], 16);
400 			idx += 16;
401 			if (idx > raw->curlen)
402 				goto fail_len;
403 			repmsg->u.link_addr.ports[i].num_sdp_streams = (raw->msg[idx] >> 4) & 0xf;
404 			repmsg->u.link_addr.ports[i].num_sdp_stream_sinks = (raw->msg[idx] & 0xf);
405 			idx++;
406 
407 		}
408 		if (idx > raw->curlen)
409 			goto fail_len;
410 	}
411 
412 	return true;
413 fail_len:
414 	DRM_DEBUG_KMS("link address reply parse length fail %d %d\n", idx, raw->curlen);
415 	return false;
416 }
417 
drm_dp_sideband_parse_remote_dpcd_read(struct drm_dp_sideband_msg_rx * raw,struct drm_dp_sideband_msg_reply_body * repmsg)418 static bool drm_dp_sideband_parse_remote_dpcd_read(struct drm_dp_sideband_msg_rx *raw,
419 						   struct drm_dp_sideband_msg_reply_body *repmsg)
420 {
421 	int idx = 1;
422 	repmsg->u.remote_dpcd_read_ack.port_number = raw->msg[idx] & 0xf;
423 	idx++;
424 	if (idx > raw->curlen)
425 		goto fail_len;
426 	repmsg->u.remote_dpcd_read_ack.num_bytes = raw->msg[idx];
427 	if (idx > raw->curlen)
428 		goto fail_len;
429 
430 	memcpy(repmsg->u.remote_dpcd_read_ack.bytes, &raw->msg[idx], repmsg->u.remote_dpcd_read_ack.num_bytes);
431 	return true;
432 fail_len:
433 	DRM_DEBUG_KMS("link address reply parse length fail %d %d\n", idx, raw->curlen);
434 	return false;
435 }
436 
drm_dp_sideband_parse_remote_dpcd_write(struct drm_dp_sideband_msg_rx * raw,struct drm_dp_sideband_msg_reply_body * repmsg)437 static bool drm_dp_sideband_parse_remote_dpcd_write(struct drm_dp_sideband_msg_rx *raw,
438 						      struct drm_dp_sideband_msg_reply_body *repmsg)
439 {
440 	int idx = 1;
441 	repmsg->u.remote_dpcd_write_ack.port_number = raw->msg[idx] & 0xf;
442 	idx++;
443 	if (idx > raw->curlen)
444 		goto fail_len;
445 	return true;
446 fail_len:
447 	DRM_DEBUG_KMS("parse length fail %d %d\n", idx, raw->curlen);
448 	return false;
449 }
450 
drm_dp_sideband_parse_remote_i2c_read_ack(struct drm_dp_sideband_msg_rx * raw,struct drm_dp_sideband_msg_reply_body * repmsg)451 static bool drm_dp_sideband_parse_remote_i2c_read_ack(struct drm_dp_sideband_msg_rx *raw,
452 						      struct drm_dp_sideband_msg_reply_body *repmsg)
453 {
454 	int idx = 1;
455 
456 	repmsg->u.remote_i2c_read_ack.port_number = (raw->msg[idx] & 0xf);
457 	idx++;
458 	if (idx > raw->curlen)
459 		goto fail_len;
460 	repmsg->u.remote_i2c_read_ack.num_bytes = raw->msg[idx];
461 	idx++;
462 	/* TODO check */
463 	memcpy(repmsg->u.remote_i2c_read_ack.bytes, &raw->msg[idx], repmsg->u.remote_i2c_read_ack.num_bytes);
464 	return true;
465 fail_len:
466 	DRM_DEBUG_KMS("remote i2c reply parse length fail %d %d\n", idx, raw->curlen);
467 	return false;
468 }
469 
drm_dp_sideband_parse_enum_path_resources_ack(struct drm_dp_sideband_msg_rx * raw,struct drm_dp_sideband_msg_reply_body * repmsg)470 static bool drm_dp_sideband_parse_enum_path_resources_ack(struct drm_dp_sideband_msg_rx *raw,
471 							  struct drm_dp_sideband_msg_reply_body *repmsg)
472 {
473 	int idx = 1;
474 	repmsg->u.path_resources.port_number = (raw->msg[idx] >> 4) & 0xf;
475 	idx++;
476 	if (idx > raw->curlen)
477 		goto fail_len;
478 	repmsg->u.path_resources.full_payload_bw_number = (raw->msg[idx] << 8) | (raw->msg[idx+1]);
479 	idx += 2;
480 	if (idx > raw->curlen)
481 		goto fail_len;
482 	repmsg->u.path_resources.avail_payload_bw_number = (raw->msg[idx] << 8) | (raw->msg[idx+1]);
483 	idx += 2;
484 	if (idx > raw->curlen)
485 		goto fail_len;
486 	return true;
487 fail_len:
488 	DRM_DEBUG_KMS("enum resource parse length fail %d %d\n", idx, raw->curlen);
489 	return false;
490 }
491 
drm_dp_sideband_parse_allocate_payload_ack(struct drm_dp_sideband_msg_rx * raw,struct drm_dp_sideband_msg_reply_body * repmsg)492 static bool drm_dp_sideband_parse_allocate_payload_ack(struct drm_dp_sideband_msg_rx *raw,
493 							  struct drm_dp_sideband_msg_reply_body *repmsg)
494 {
495 	int idx = 1;
496 	repmsg->u.allocate_payload.port_number = (raw->msg[idx] >> 4) & 0xf;
497 	idx++;
498 	if (idx > raw->curlen)
499 		goto fail_len;
500 	repmsg->u.allocate_payload.vcpi = raw->msg[idx];
501 	idx++;
502 	if (idx > raw->curlen)
503 		goto fail_len;
504 	repmsg->u.allocate_payload.allocated_pbn = (raw->msg[idx] << 8) | (raw->msg[idx+1]);
505 	idx += 2;
506 	if (idx > raw->curlen)
507 		goto fail_len;
508 	return true;
509 fail_len:
510 	DRM_DEBUG_KMS("allocate payload parse length fail %d %d\n", idx, raw->curlen);
511 	return false;
512 }
513 
drm_dp_sideband_parse_query_payload_ack(struct drm_dp_sideband_msg_rx * raw,struct drm_dp_sideband_msg_reply_body * repmsg)514 static bool drm_dp_sideband_parse_query_payload_ack(struct drm_dp_sideband_msg_rx *raw,
515 						    struct drm_dp_sideband_msg_reply_body *repmsg)
516 {
517 	int idx = 1;
518 	repmsg->u.query_payload.port_number = (raw->msg[idx] >> 4) & 0xf;
519 	idx++;
520 	if (idx > raw->curlen)
521 		goto fail_len;
522 	repmsg->u.query_payload.allocated_pbn = (raw->msg[idx] << 8) | (raw->msg[idx + 1]);
523 	idx += 2;
524 	if (idx > raw->curlen)
525 		goto fail_len;
526 	return true;
527 fail_len:
528 	DRM_DEBUG_KMS("query payload parse length fail %d %d\n", idx, raw->curlen);
529 	return false;
530 }
531 
drm_dp_sideband_parse_reply(struct drm_dp_sideband_msg_rx * raw,struct drm_dp_sideband_msg_reply_body * msg)532 static bool drm_dp_sideband_parse_reply(struct drm_dp_sideband_msg_rx *raw,
533 					struct drm_dp_sideband_msg_reply_body *msg)
534 {
535 	memset(msg, 0, sizeof(*msg));
536 	msg->reply_type = (raw->msg[0] & 0x80) >> 7;
537 	msg->req_type = (raw->msg[0] & 0x7f);
538 
539 	if (msg->reply_type) {
540 		memcpy(msg->u.nak.guid, &raw->msg[1], 16);
541 		msg->u.nak.reason = raw->msg[17];
542 		msg->u.nak.nak_data = raw->msg[18];
543 		return false;
544 	}
545 
546 	switch (msg->req_type) {
547 	case DP_LINK_ADDRESS:
548 		return drm_dp_sideband_parse_link_address(raw, msg);
549 	case DP_QUERY_PAYLOAD:
550 		return drm_dp_sideband_parse_query_payload_ack(raw, msg);
551 	case DP_REMOTE_DPCD_READ:
552 		return drm_dp_sideband_parse_remote_dpcd_read(raw, msg);
553 	case DP_REMOTE_DPCD_WRITE:
554 		return drm_dp_sideband_parse_remote_dpcd_write(raw, msg);
555 	case DP_REMOTE_I2C_READ:
556 		return drm_dp_sideband_parse_remote_i2c_read_ack(raw, msg);
557 	case DP_ENUM_PATH_RESOURCES:
558 		return drm_dp_sideband_parse_enum_path_resources_ack(raw, msg);
559 	case DP_ALLOCATE_PAYLOAD:
560 		return drm_dp_sideband_parse_allocate_payload_ack(raw, msg);
561 	default:
562 		DRM_ERROR("Got unknown reply 0x%02x\n", msg->req_type);
563 		return false;
564 	}
565 }
566 
drm_dp_sideband_parse_connection_status_notify(struct drm_dp_sideband_msg_rx * raw,struct drm_dp_sideband_msg_req_body * msg)567 static bool drm_dp_sideband_parse_connection_status_notify(struct drm_dp_sideband_msg_rx *raw,
568 							   struct drm_dp_sideband_msg_req_body *msg)
569 {
570 	int idx = 1;
571 
572 	msg->u.conn_stat.port_number = (raw->msg[idx] & 0xf0) >> 4;
573 	idx++;
574 	if (idx > raw->curlen)
575 		goto fail_len;
576 
577 	memcpy(msg->u.conn_stat.guid, &raw->msg[idx], 16);
578 	idx += 16;
579 	if (idx > raw->curlen)
580 		goto fail_len;
581 
582 	msg->u.conn_stat.legacy_device_plug_status = (raw->msg[idx] >> 6) & 0x1;
583 	msg->u.conn_stat.displayport_device_plug_status = (raw->msg[idx] >> 5) & 0x1;
584 	msg->u.conn_stat.message_capability_status = (raw->msg[idx] >> 4) & 0x1;
585 	msg->u.conn_stat.input_port = (raw->msg[idx] >> 3) & 0x1;
586 	msg->u.conn_stat.peer_device_type = (raw->msg[idx] & 0x7);
587 	idx++;
588 	return true;
589 fail_len:
590 	DRM_DEBUG_KMS("connection status reply parse length fail %d %d\n", idx, raw->curlen);
591 	return false;
592 }
593 
drm_dp_sideband_parse_resource_status_notify(struct drm_dp_sideband_msg_rx * raw,struct drm_dp_sideband_msg_req_body * msg)594 static bool drm_dp_sideband_parse_resource_status_notify(struct drm_dp_sideband_msg_rx *raw,
595 							   struct drm_dp_sideband_msg_req_body *msg)
596 {
597 	int idx = 1;
598 
599 	msg->u.resource_stat.port_number = (raw->msg[idx] & 0xf0) >> 4;
600 	idx++;
601 	if (idx > raw->curlen)
602 		goto fail_len;
603 
604 	memcpy(msg->u.resource_stat.guid, &raw->msg[idx], 16);
605 	idx += 16;
606 	if (idx > raw->curlen)
607 		goto fail_len;
608 
609 	msg->u.resource_stat.available_pbn = (raw->msg[idx] << 8) | (raw->msg[idx + 1]);
610 	idx++;
611 	return true;
612 fail_len:
613 	DRM_DEBUG_KMS("resource status reply parse length fail %d %d\n", idx, raw->curlen);
614 	return false;
615 }
616 
drm_dp_sideband_parse_req(struct drm_dp_sideband_msg_rx * raw,struct drm_dp_sideband_msg_req_body * msg)617 static bool drm_dp_sideband_parse_req(struct drm_dp_sideband_msg_rx *raw,
618 				      struct drm_dp_sideband_msg_req_body *msg)
619 {
620 	memset(msg, 0, sizeof(*msg));
621 	msg->req_type = (raw->msg[0] & 0x7f);
622 
623 	switch (msg->req_type) {
624 	case DP_CONNECTION_STATUS_NOTIFY:
625 		return drm_dp_sideband_parse_connection_status_notify(raw, msg);
626 	case DP_RESOURCE_STATUS_NOTIFY:
627 		return drm_dp_sideband_parse_resource_status_notify(raw, msg);
628 	default:
629 		DRM_ERROR("Got unknown request 0x%02x\n", msg->req_type);
630 		return false;
631 	}
632 }
633 
build_dpcd_write(struct drm_dp_sideband_msg_tx * msg,u8 port_num,u32 offset,u8 num_bytes,u8 * bytes)634 static int build_dpcd_write(struct drm_dp_sideband_msg_tx *msg, u8 port_num, u32 offset, u8 num_bytes, u8 *bytes)
635 {
636 	struct drm_dp_sideband_msg_req_body req;
637 
638 	req.req_type = DP_REMOTE_DPCD_WRITE;
639 	req.u.dpcd_write.port_number = port_num;
640 	req.u.dpcd_write.dpcd_address = offset;
641 	req.u.dpcd_write.num_bytes = num_bytes;
642 	req.u.dpcd_write.bytes = bytes;
643 	drm_dp_encode_sideband_req(&req, msg);
644 
645 	return 0;
646 }
647 
build_link_address(struct drm_dp_sideband_msg_tx * msg)648 static int build_link_address(struct drm_dp_sideband_msg_tx *msg)
649 {
650 	struct drm_dp_sideband_msg_req_body req;
651 
652 	req.req_type = DP_LINK_ADDRESS;
653 	drm_dp_encode_sideband_req(&req, msg);
654 	return 0;
655 }
656 
build_enum_path_resources(struct drm_dp_sideband_msg_tx * msg,int port_num)657 static int build_enum_path_resources(struct drm_dp_sideband_msg_tx *msg, int port_num)
658 {
659 	struct drm_dp_sideband_msg_req_body req;
660 
661 	req.req_type = DP_ENUM_PATH_RESOURCES;
662 	req.u.port_num.port_number = port_num;
663 	drm_dp_encode_sideband_req(&req, msg);
664 	msg->path_msg = true;
665 	return 0;
666 }
667 
build_allocate_payload(struct drm_dp_sideband_msg_tx * msg,int port_num,u8 vcpi,uint16_t pbn)668 static int build_allocate_payload(struct drm_dp_sideband_msg_tx *msg, int port_num,
669 				  u8 vcpi, uint16_t pbn)
670 {
671 	struct drm_dp_sideband_msg_req_body req;
672 	memset(&req, 0, sizeof(req));
673 	req.req_type = DP_ALLOCATE_PAYLOAD;
674 	req.u.allocate_payload.port_number = port_num;
675 	req.u.allocate_payload.vcpi = vcpi;
676 	req.u.allocate_payload.pbn = pbn;
677 	drm_dp_encode_sideband_req(&req, msg);
678 	msg->path_msg = true;
679 	return 0;
680 }
681 
drm_dp_mst_assign_payload_id(struct drm_dp_mst_topology_mgr * mgr,struct drm_dp_vcpi * vcpi)682 static int drm_dp_mst_assign_payload_id(struct drm_dp_mst_topology_mgr *mgr,
683 					struct drm_dp_vcpi *vcpi)
684 {
685 	int ret, vcpi_ret;
686 
687 	mutex_lock(&mgr->payload_lock);
688 	ret = find_first_zero_bit(&mgr->payload_mask, mgr->max_payloads + 1);
689 	if (ret > mgr->max_payloads) {
690 		ret = -EINVAL;
691 		DRM_DEBUG_KMS("out of payload ids %d\n", ret);
692 		goto out_unlock;
693 	}
694 
695 	vcpi_ret = find_first_zero_bit(&mgr->vcpi_mask, mgr->max_payloads + 1);
696 	if (vcpi_ret > mgr->max_payloads) {
697 		ret = -EINVAL;
698 		DRM_DEBUG_KMS("out of vcpi ids %d\n", ret);
699 		goto out_unlock;
700 	}
701 
702 	set_bit(ret, &mgr->payload_mask);
703 	set_bit(vcpi_ret, &mgr->vcpi_mask);
704 	vcpi->vcpi = vcpi_ret + 1;
705 	mgr->proposed_vcpis[ret - 1] = vcpi;
706 out_unlock:
707 	mutex_unlock(&mgr->payload_lock);
708 	return ret;
709 }
710 
drm_dp_mst_put_payload_id(struct drm_dp_mst_topology_mgr * mgr,int vcpi)711 static void drm_dp_mst_put_payload_id(struct drm_dp_mst_topology_mgr *mgr,
712 				      int vcpi)
713 {
714 	int i;
715 	if (vcpi == 0)
716 		return;
717 
718 	mutex_lock(&mgr->payload_lock);
719 	DRM_DEBUG_KMS("putting payload %d\n", vcpi);
720 	clear_bit(vcpi - 1, &mgr->vcpi_mask);
721 
722 	for (i = 0; i < mgr->max_payloads; i++) {
723 		if (mgr->proposed_vcpis[i])
724 			if (mgr->proposed_vcpis[i]->vcpi == vcpi) {
725 				mgr->proposed_vcpis[i] = NULL;
726 				clear_bit(i + 1, &mgr->payload_mask);
727 			}
728 	}
729 	mutex_unlock(&mgr->payload_lock);
730 }
731 
check_txmsg_state(struct drm_dp_mst_topology_mgr * mgr,struct drm_dp_sideband_msg_tx * txmsg)732 static bool check_txmsg_state(struct drm_dp_mst_topology_mgr *mgr,
733 			      struct drm_dp_sideband_msg_tx *txmsg)
734 {
735 	bool ret;
736 
737 	/*
738 	 * All updates to txmsg->state are protected by mgr->qlock, and the two
739 	 * cases we check here are terminal states. For those the barriers
740 	 * provided by the wake_up/wait_event pair are enough.
741 	 */
742 	ret = (txmsg->state == DRM_DP_SIDEBAND_TX_RX ||
743 	       txmsg->state == DRM_DP_SIDEBAND_TX_TIMEOUT);
744 	return ret;
745 }
746 
drm_dp_mst_wait_tx_reply(struct drm_dp_mst_branch * mstb,struct drm_dp_sideband_msg_tx * txmsg)747 static int drm_dp_mst_wait_tx_reply(struct drm_dp_mst_branch *mstb,
748 				    struct drm_dp_sideband_msg_tx *txmsg)
749 {
750 	struct drm_dp_mst_topology_mgr *mgr = mstb->mgr;
751 	int ret;
752 
753 	ret = wait_event_timeout(mgr->tx_waitq,
754 				 check_txmsg_state(mgr, txmsg),
755 				 (4 * HZ));
756 	mutex_lock(&mstb->mgr->qlock);
757 	if (ret > 0) {
758 		if (txmsg->state == DRM_DP_SIDEBAND_TX_TIMEOUT) {
759 			ret = -EIO;
760 			goto out;
761 		}
762 	} else {
763 		DRM_DEBUG_KMS("timedout msg send %p %d %d\n", txmsg, txmsg->state, txmsg->seqno);
764 
765 		/* dump some state */
766 		ret = -EIO;
767 
768 		/* remove from q */
769 		if (txmsg->state == DRM_DP_SIDEBAND_TX_QUEUED ||
770 		    txmsg->state == DRM_DP_SIDEBAND_TX_START_SEND) {
771 			list_del(&txmsg->next);
772 		}
773 
774 		if (txmsg->state == DRM_DP_SIDEBAND_TX_START_SEND ||
775 		    txmsg->state == DRM_DP_SIDEBAND_TX_SENT) {
776 			mstb->tx_slots[txmsg->seqno] = NULL;
777 		}
778 	}
779 out:
780 	mutex_unlock(&mgr->qlock);
781 
782 	return ret;
783 }
784 
drm_dp_add_mst_branch_device(u8 lct,u8 * rad)785 static struct drm_dp_mst_branch *drm_dp_add_mst_branch_device(u8 lct, u8 *rad)
786 {
787 	struct drm_dp_mst_branch *mstb;
788 
789 	mstb = kzalloc(sizeof(*mstb), GFP_KERNEL);
790 	if (!mstb)
791 		return NULL;
792 
793 	mstb->lct = lct;
794 	if (lct > 1)
795 		memcpy(mstb->rad, rad, lct / 2);
796 	INIT_LIST_HEAD(&mstb->ports);
797 	kref_init(&mstb->kref);
798 	return mstb;
799 }
800 
801 static void drm_dp_free_mst_port(struct kref *kref);
802 
drm_dp_free_mst_branch_device(struct kref * kref)803 static void drm_dp_free_mst_branch_device(struct kref *kref)
804 {
805 	struct drm_dp_mst_branch *mstb = container_of(kref, struct drm_dp_mst_branch, kref);
806 	if (mstb->port_parent) {
807 		if (list_empty(&mstb->port_parent->next))
808 			kref_put(&mstb->port_parent->kref, drm_dp_free_mst_port);
809 	}
810 	kfree(mstb);
811 }
812 
drm_dp_destroy_mst_branch_device(struct kref * kref)813 static void drm_dp_destroy_mst_branch_device(struct kref *kref)
814 {
815 	struct drm_dp_mst_branch *mstb = container_of(kref, struct drm_dp_mst_branch, kref);
816 	struct drm_dp_mst_port *port, *tmp;
817 	bool wake_tx = false;
818 
819 	/*
820 	 * init kref again to be used by ports to remove mst branch when it is
821 	 * not needed anymore
822 	 */
823 	kref_init(kref);
824 
825 	if (mstb->port_parent && list_empty(&mstb->port_parent->next))
826 		kref_get(&mstb->port_parent->kref);
827 
828 	/*
829 	 * destroy all ports - don't need lock
830 	 * as there are no more references to the mst branch
831 	 * device at this point.
832 	 */
833 	list_for_each_entry_safe(port, tmp, &mstb->ports, next) {
834 		list_del(&port->next);
835 		drm_dp_put_port(port);
836 	}
837 
838 	/* drop any tx slots msg */
839 	mutex_lock(&mstb->mgr->qlock);
840 	if (mstb->tx_slots[0]) {
841 		mstb->tx_slots[0]->state = DRM_DP_SIDEBAND_TX_TIMEOUT;
842 		mstb->tx_slots[0] = NULL;
843 		wake_tx = true;
844 	}
845 	if (mstb->tx_slots[1]) {
846 		mstb->tx_slots[1]->state = DRM_DP_SIDEBAND_TX_TIMEOUT;
847 		mstb->tx_slots[1] = NULL;
848 		wake_tx = true;
849 	}
850 	mutex_unlock(&mstb->mgr->qlock);
851 
852 	if (wake_tx)
853 		wake_up(&mstb->mgr->tx_waitq);
854 
855 	kref_put(kref, drm_dp_free_mst_branch_device);
856 }
857 
drm_dp_put_mst_branch_device(struct drm_dp_mst_branch * mstb)858 static void drm_dp_put_mst_branch_device(struct drm_dp_mst_branch *mstb)
859 {
860 	kref_put(&mstb->kref, drm_dp_destroy_mst_branch_device);
861 }
862 
863 
drm_dp_port_teardown_pdt(struct drm_dp_mst_port * port,int old_pdt)864 static void drm_dp_port_teardown_pdt(struct drm_dp_mst_port *port, int old_pdt)
865 {
866 	struct drm_dp_mst_branch *mstb;
867 
868 	switch (old_pdt) {
869 	case DP_PEER_DEVICE_DP_LEGACY_CONV:
870 	case DP_PEER_DEVICE_SST_SINK:
871 		/* remove i2c over sideband */
872 		drm_dp_mst_unregister_i2c_bus(&port->aux);
873 		break;
874 	case DP_PEER_DEVICE_MST_BRANCHING:
875 		mstb = port->mstb;
876 		port->mstb = NULL;
877 		drm_dp_put_mst_branch_device(mstb);
878 		break;
879 	}
880 }
881 
drm_dp_destroy_port(struct kref * kref)882 static void drm_dp_destroy_port(struct kref *kref)
883 {
884 	struct drm_dp_mst_port *port = container_of(kref, struct drm_dp_mst_port, kref);
885 	struct drm_dp_mst_topology_mgr *mgr = port->mgr;
886 
887 	if (!port->input) {
888 		port->vcpi.num_slots = 0;
889 
890 		kfree(port->cached_edid);
891 
892 		/*
893 		 * The only time we don't have a connector
894 		 * on an output port is if the connector init
895 		 * fails.
896 		 */
897 		if (port->connector) {
898 			/* we can't destroy the connector here, as
899 			 * we might be holding the mode_config.mutex
900 			 * from an EDID retrieval */
901 
902 			mutex_lock(&mgr->destroy_connector_lock);
903 			kref_get(&port->parent->kref);
904 			list_add(&port->next, &mgr->destroy_connector_list);
905 			mutex_unlock(&mgr->destroy_connector_lock);
906 			schedule_work(&mgr->destroy_connector_work);
907 			return;
908 		}
909 		/* no need to clean up vcpi
910 		 * as if we have no connector we never setup a vcpi */
911 		drm_dp_port_teardown_pdt(port, port->pdt);
912 	}
913 	kfree(port);
914 }
915 
drm_dp_put_port(struct drm_dp_mst_port * port)916 static void drm_dp_put_port(struct drm_dp_mst_port *port)
917 {
918 	kref_put(&port->kref, drm_dp_destroy_port);
919 }
920 
drm_dp_mst_get_validated_mstb_ref_locked(struct drm_dp_mst_branch * mstb,struct drm_dp_mst_branch * to_find)921 static struct drm_dp_mst_branch *drm_dp_mst_get_validated_mstb_ref_locked(struct drm_dp_mst_branch *mstb, struct drm_dp_mst_branch *to_find)
922 {
923 	struct drm_dp_mst_port *port;
924 	struct drm_dp_mst_branch *rmstb;
925 	if (to_find == mstb) {
926 		kref_get(&mstb->kref);
927 		return mstb;
928 	}
929 	list_for_each_entry(port, &mstb->ports, next) {
930 		if (port->mstb) {
931 			rmstb = drm_dp_mst_get_validated_mstb_ref_locked(port->mstb, to_find);
932 			if (rmstb)
933 				return rmstb;
934 		}
935 	}
936 	return NULL;
937 }
938 
drm_dp_get_validated_mstb_ref(struct drm_dp_mst_topology_mgr * mgr,struct drm_dp_mst_branch * mstb)939 static struct drm_dp_mst_branch *drm_dp_get_validated_mstb_ref(struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_branch *mstb)
940 {
941 	struct drm_dp_mst_branch *rmstb = NULL;
942 	mutex_lock(&mgr->lock);
943 	if (mgr->mst_primary)
944 		rmstb = drm_dp_mst_get_validated_mstb_ref_locked(mgr->mst_primary, mstb);
945 	mutex_unlock(&mgr->lock);
946 	return rmstb;
947 }
948 
drm_dp_mst_get_port_ref_locked(struct drm_dp_mst_branch * mstb,struct drm_dp_mst_port * to_find)949 static struct drm_dp_mst_port *drm_dp_mst_get_port_ref_locked(struct drm_dp_mst_branch *mstb, struct drm_dp_mst_port *to_find)
950 {
951 	struct drm_dp_mst_port *port, *mport;
952 
953 	list_for_each_entry(port, &mstb->ports, next) {
954 		if (port == to_find) {
955 			kref_get(&port->kref);
956 			return port;
957 		}
958 		if (port->mstb) {
959 			mport = drm_dp_mst_get_port_ref_locked(port->mstb, to_find);
960 			if (mport)
961 				return mport;
962 		}
963 	}
964 	return NULL;
965 }
966 
drm_dp_get_validated_port_ref(struct drm_dp_mst_topology_mgr * mgr,struct drm_dp_mst_port * port)967 static struct drm_dp_mst_port *drm_dp_get_validated_port_ref(struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port)
968 {
969 	struct drm_dp_mst_port *rport = NULL;
970 	mutex_lock(&mgr->lock);
971 	if (mgr->mst_primary)
972 		rport = drm_dp_mst_get_port_ref_locked(mgr->mst_primary, port);
973 	mutex_unlock(&mgr->lock);
974 	return rport;
975 }
976 
drm_dp_get_port(struct drm_dp_mst_branch * mstb,u8 port_num)977 static struct drm_dp_mst_port *drm_dp_get_port(struct drm_dp_mst_branch *mstb, u8 port_num)
978 {
979 	struct drm_dp_mst_port *port;
980 
981 	list_for_each_entry(port, &mstb->ports, next) {
982 		if (port->port_num == port_num) {
983 			kref_get(&port->kref);
984 			return port;
985 		}
986 	}
987 
988 	return NULL;
989 }
990 
991 /*
992  * calculate a new RAD for this MST branch device
993  * if parent has an LCT of 2 then it has 1 nibble of RAD,
994  * if parent has an LCT of 3 then it has 2 nibbles of RAD,
995  */
drm_dp_calculate_rad(struct drm_dp_mst_port * port,u8 * rad)996 static u8 drm_dp_calculate_rad(struct drm_dp_mst_port *port,
997 				 u8 *rad)
998 {
999 	int parent_lct = port->parent->lct;
1000 	int shift = 4;
1001 	int idx = (parent_lct - 1) / 2;
1002 	if (parent_lct > 1) {
1003 		memcpy(rad, port->parent->rad, idx + 1);
1004 		shift = (parent_lct % 2) ? 4 : 0;
1005 	} else
1006 		rad[0] = 0;
1007 
1008 	rad[idx] |= port->port_num << shift;
1009 	return parent_lct + 1;
1010 }
1011 
1012 /*
1013  * return sends link address for new mstb
1014  */
drm_dp_port_setup_pdt(struct drm_dp_mst_port * port)1015 static bool drm_dp_port_setup_pdt(struct drm_dp_mst_port *port)
1016 {
1017 	int ret;
1018 	u8 rad[6], lct;
1019 	bool send_link = false;
1020 	switch (port->pdt) {
1021 	case DP_PEER_DEVICE_DP_LEGACY_CONV:
1022 	case DP_PEER_DEVICE_SST_SINK:
1023 		/* add i2c over sideband */
1024 		ret = drm_dp_mst_register_i2c_bus(&port->aux);
1025 		break;
1026 	case DP_PEER_DEVICE_MST_BRANCHING:
1027 		lct = drm_dp_calculate_rad(port, rad);
1028 
1029 		port->mstb = drm_dp_add_mst_branch_device(lct, rad);
1030 		port->mstb->mgr = port->mgr;
1031 		port->mstb->port_parent = port;
1032 
1033 		send_link = true;
1034 		break;
1035 	}
1036 	return send_link;
1037 }
1038 
drm_dp_check_mstb_guid(struct drm_dp_mst_branch * mstb,u8 * guid)1039 static void drm_dp_check_mstb_guid(struct drm_dp_mst_branch *mstb, u8 *guid)
1040 {
1041 	int ret;
1042 
1043 	memcpy(mstb->guid, guid, 16);
1044 
1045 	if (!drm_dp_validate_guid(mstb->mgr, mstb->guid)) {
1046 		if (mstb->port_parent) {
1047 			ret = drm_dp_send_dpcd_write(
1048 					mstb->mgr,
1049 					mstb->port_parent,
1050 					DP_GUID,
1051 					16,
1052 					mstb->guid);
1053 		} else {
1054 
1055 			ret = drm_dp_dpcd_write(
1056 					mstb->mgr->aux,
1057 					DP_GUID,
1058 					mstb->guid,
1059 					16);
1060 		}
1061 	}
1062 }
1063 
build_mst_prop_path(const struct drm_dp_mst_branch * mstb,int pnum,char * proppath,size_t proppath_size)1064 static void build_mst_prop_path(const struct drm_dp_mst_branch *mstb,
1065 				int pnum,
1066 				char *proppath,
1067 				size_t proppath_size)
1068 {
1069 	int i;
1070 	char temp[8];
1071 	snprintf(proppath, proppath_size, "mst:%d", mstb->mgr->conn_base_id);
1072 	for (i = 0; i < (mstb->lct - 1); i++) {
1073 		int shift = (i % 2) ? 0 : 4;
1074 		int port_num = (mstb->rad[i / 2] >> shift) & 0xf;
1075 		snprintf(temp, sizeof(temp), "-%d", port_num);
1076 		strlcat(proppath, temp, proppath_size);
1077 	}
1078 	snprintf(temp, sizeof(temp), "-%d", pnum);
1079 	strlcat(proppath, temp, proppath_size);
1080 }
1081 
drm_dp_add_port(struct drm_dp_mst_branch * mstb,struct device * dev,struct drm_dp_link_addr_reply_port * port_msg)1082 static void drm_dp_add_port(struct drm_dp_mst_branch *mstb,
1083 			    struct device *dev,
1084 			    struct drm_dp_link_addr_reply_port *port_msg)
1085 {
1086 	struct drm_dp_mst_port *port;
1087 	bool ret;
1088 	bool created = false;
1089 	int old_pdt = 0;
1090 	int old_ddps = 0;
1091 	port = drm_dp_get_port(mstb, port_msg->port_number);
1092 	if (!port) {
1093 		port = kzalloc(sizeof(*port), GFP_KERNEL);
1094 		if (!port)
1095 			return;
1096 		kref_init(&port->kref);
1097 		port->parent = mstb;
1098 		port->port_num = port_msg->port_number;
1099 		port->mgr = mstb->mgr;
1100 		port->aux.name = "DPMST";
1101 		port->aux.dev = dev;
1102 		created = true;
1103 	} else {
1104 		old_pdt = port->pdt;
1105 		old_ddps = port->ddps;
1106 	}
1107 
1108 	port->pdt = port_msg->peer_device_type;
1109 	port->input = port_msg->input_port;
1110 	port->mcs = port_msg->mcs;
1111 	port->ddps = port_msg->ddps;
1112 	port->ldps = port_msg->legacy_device_plug_status;
1113 	port->dpcd_rev = port_msg->dpcd_revision;
1114 	port->num_sdp_streams = port_msg->num_sdp_streams;
1115 	port->num_sdp_stream_sinks = port_msg->num_sdp_stream_sinks;
1116 
1117 	/* manage mstb port lists with mgr lock - take a reference
1118 	   for this list */
1119 	if (created) {
1120 		mutex_lock(&mstb->mgr->lock);
1121 		kref_get(&port->kref);
1122 		list_add(&port->next, &mstb->ports);
1123 		mutex_unlock(&mstb->mgr->lock);
1124 	}
1125 
1126 	if (old_ddps != port->ddps) {
1127 		if (port->ddps) {
1128 			if (!port->input)
1129 				drm_dp_send_enum_path_resources(mstb->mgr, mstb, port);
1130 		} else {
1131 			port->available_pbn = 0;
1132 			}
1133 	}
1134 
1135 	if (old_pdt != port->pdt && !port->input) {
1136 		drm_dp_port_teardown_pdt(port, old_pdt);
1137 
1138 		ret = drm_dp_port_setup_pdt(port);
1139 		if (ret == true)
1140 			drm_dp_send_link_address(mstb->mgr, port->mstb);
1141 	}
1142 
1143 	if (created && !port->input) {
1144 		char proppath[255];
1145 
1146 		build_mst_prop_path(mstb, port->port_num, proppath, sizeof(proppath));
1147 		port->connector = (*mstb->mgr->cbs->add_connector)(mstb->mgr, port, proppath);
1148 		if (!port->connector) {
1149 			/* remove it from the port list */
1150 			mutex_lock(&mstb->mgr->lock);
1151 			list_del(&port->next);
1152 			mutex_unlock(&mstb->mgr->lock);
1153 			/* drop port list reference */
1154 			drm_dp_put_port(port);
1155 			goto out;
1156 		}
1157 		if (port->port_num >= DP_MST_LOGICAL_PORT_0) {
1158 			port->cached_edid = drm_get_edid(port->connector, &port->aux.ddc);
1159 			drm_mode_connector_set_tile_property(port->connector);
1160 		}
1161 		(*mstb->mgr->cbs->register_connector)(port->connector);
1162 	}
1163 
1164 out:
1165 	/* put reference to this port */
1166 	drm_dp_put_port(port);
1167 }
1168 
drm_dp_update_port(struct drm_dp_mst_branch * mstb,struct drm_dp_connection_status_notify * conn_stat)1169 static void drm_dp_update_port(struct drm_dp_mst_branch *mstb,
1170 			       struct drm_dp_connection_status_notify *conn_stat)
1171 {
1172 	struct drm_dp_mst_port *port;
1173 	int old_pdt;
1174 	int old_ddps;
1175 	bool dowork = false;
1176 	port = drm_dp_get_port(mstb, conn_stat->port_number);
1177 	if (!port)
1178 		return;
1179 
1180 	old_ddps = port->ddps;
1181 	old_pdt = port->pdt;
1182 	port->pdt = conn_stat->peer_device_type;
1183 	port->mcs = conn_stat->message_capability_status;
1184 	port->ldps = conn_stat->legacy_device_plug_status;
1185 	port->ddps = conn_stat->displayport_device_plug_status;
1186 
1187 	if (old_ddps != port->ddps) {
1188 		if (port->ddps) {
1189 			dowork = true;
1190 		} else {
1191 			port->available_pbn = 0;
1192 		}
1193 	}
1194 	if (old_pdt != port->pdt && !port->input) {
1195 		drm_dp_port_teardown_pdt(port, old_pdt);
1196 
1197 		if (drm_dp_port_setup_pdt(port))
1198 			dowork = true;
1199 	}
1200 
1201 	drm_dp_put_port(port);
1202 	if (dowork)
1203 		queue_work(system_long_wq, &mstb->mgr->work);
1204 
1205 }
1206 
drm_dp_get_mst_branch_device(struct drm_dp_mst_topology_mgr * mgr,u8 lct,u8 * rad)1207 static struct drm_dp_mst_branch *drm_dp_get_mst_branch_device(struct drm_dp_mst_topology_mgr *mgr,
1208 							       u8 lct, u8 *rad)
1209 {
1210 	struct drm_dp_mst_branch *mstb;
1211 	struct drm_dp_mst_port *port;
1212 	int i;
1213 	/* find the port by iterating down */
1214 
1215 	mutex_lock(&mgr->lock);
1216 	mstb = mgr->mst_primary;
1217 
1218 	for (i = 0; i < lct - 1; i++) {
1219 		int shift = (i % 2) ? 0 : 4;
1220 		int port_num = (rad[i / 2] >> shift) & 0xf;
1221 
1222 		list_for_each_entry(port, &mstb->ports, next) {
1223 			if (port->port_num == port_num) {
1224 				mstb = port->mstb;
1225 				if (!mstb) {
1226 					DRM_ERROR("failed to lookup MSTB with lct %d, rad %02x\n", lct, rad[0]);
1227 					goto out;
1228 				}
1229 
1230 				break;
1231 			}
1232 		}
1233 	}
1234 	kref_get(&mstb->kref);
1235 out:
1236 	mutex_unlock(&mgr->lock);
1237 	return mstb;
1238 }
1239 
get_mst_branch_device_by_guid_helper(struct drm_dp_mst_branch * mstb,uint8_t * guid)1240 static struct drm_dp_mst_branch *get_mst_branch_device_by_guid_helper(
1241 	struct drm_dp_mst_branch *mstb,
1242 	uint8_t *guid)
1243 {
1244 	struct drm_dp_mst_branch *found_mstb;
1245 	struct drm_dp_mst_port *port;
1246 
1247 	if (memcmp(mstb->guid, guid, 16) == 0)
1248 		return mstb;
1249 
1250 
1251 	list_for_each_entry(port, &mstb->ports, next) {
1252 		if (!port->mstb)
1253 			continue;
1254 
1255 		found_mstb = get_mst_branch_device_by_guid_helper(port->mstb, guid);
1256 
1257 		if (found_mstb)
1258 			return found_mstb;
1259 	}
1260 
1261 	return NULL;
1262 }
1263 
drm_dp_get_mst_branch_device_by_guid(struct drm_dp_mst_topology_mgr * mgr,uint8_t * guid)1264 static struct drm_dp_mst_branch *drm_dp_get_mst_branch_device_by_guid(
1265 	struct drm_dp_mst_topology_mgr *mgr,
1266 	uint8_t *guid)
1267 {
1268 	struct drm_dp_mst_branch *mstb;
1269 
1270 	/* find the port by iterating down */
1271 	mutex_lock(&mgr->lock);
1272 
1273 	mstb = get_mst_branch_device_by_guid_helper(mgr->mst_primary, guid);
1274 
1275 	if (mstb)
1276 		kref_get(&mstb->kref);
1277 
1278 	mutex_unlock(&mgr->lock);
1279 	return mstb;
1280 }
1281 
drm_dp_check_and_send_link_address(struct drm_dp_mst_topology_mgr * mgr,struct drm_dp_mst_branch * mstb)1282 static void drm_dp_check_and_send_link_address(struct drm_dp_mst_topology_mgr *mgr,
1283 					       struct drm_dp_mst_branch *mstb)
1284 {
1285 	struct drm_dp_mst_port *port;
1286 	struct drm_dp_mst_branch *mstb_child;
1287 	if (!mstb->link_address_sent)
1288 		drm_dp_send_link_address(mgr, mstb);
1289 
1290 	list_for_each_entry(port, &mstb->ports, next) {
1291 		if (port->input)
1292 			continue;
1293 
1294 		if (!port->ddps)
1295 			continue;
1296 
1297 		if (!port->available_pbn)
1298 			drm_dp_send_enum_path_resources(mgr, mstb, port);
1299 
1300 		if (port->mstb) {
1301 			mstb_child = drm_dp_get_validated_mstb_ref(mgr, port->mstb);
1302 			if (mstb_child) {
1303 				drm_dp_check_and_send_link_address(mgr, mstb_child);
1304 				drm_dp_put_mst_branch_device(mstb_child);
1305 			}
1306 		}
1307 	}
1308 }
1309 
drm_dp_mst_link_probe_work(struct work_struct * work)1310 static void drm_dp_mst_link_probe_work(struct work_struct *work)
1311 {
1312 	struct drm_dp_mst_topology_mgr *mgr = container_of(work, struct drm_dp_mst_topology_mgr, work);
1313 	struct drm_dp_mst_branch *mstb;
1314 
1315 	mutex_lock(&mgr->lock);
1316 	mstb = mgr->mst_primary;
1317 	if (mstb) {
1318 		kref_get(&mstb->kref);
1319 	}
1320 	mutex_unlock(&mgr->lock);
1321 	if (mstb) {
1322 		drm_dp_check_and_send_link_address(mgr, mstb);
1323 		drm_dp_put_mst_branch_device(mstb);
1324 	}
1325 }
1326 
drm_dp_validate_guid(struct drm_dp_mst_topology_mgr * mgr,u8 * guid)1327 static bool drm_dp_validate_guid(struct drm_dp_mst_topology_mgr *mgr,
1328 				 u8 *guid)
1329 {
1330 	static u8 zero_guid[16];
1331 
1332 	if (!memcmp(guid, zero_guid, 16)) {
1333 		u64 salt = get_jiffies_64();
1334 		memcpy(&guid[0], &salt, sizeof(u64));
1335 		memcpy(&guid[8], &salt, sizeof(u64));
1336 		return false;
1337 	}
1338 	return true;
1339 }
1340 
1341 #if 0
1342 static int build_dpcd_read(struct drm_dp_sideband_msg_tx *msg, u8 port_num, u32 offset, u8 num_bytes)
1343 {
1344 	struct drm_dp_sideband_msg_req_body req;
1345 
1346 	req.req_type = DP_REMOTE_DPCD_READ;
1347 	req.u.dpcd_read.port_number = port_num;
1348 	req.u.dpcd_read.dpcd_address = offset;
1349 	req.u.dpcd_read.num_bytes = num_bytes;
1350 	drm_dp_encode_sideband_req(&req, msg);
1351 
1352 	return 0;
1353 }
1354 #endif
1355 
drm_dp_send_sideband_msg(struct drm_dp_mst_topology_mgr * mgr,bool up,u8 * msg,int len)1356 static int drm_dp_send_sideband_msg(struct drm_dp_mst_topology_mgr *mgr,
1357 				    bool up, u8 *msg, int len)
1358 {
1359 	int ret;
1360 	int regbase = up ? DP_SIDEBAND_MSG_UP_REP_BASE : DP_SIDEBAND_MSG_DOWN_REQ_BASE;
1361 	int tosend, total, offset;
1362 	int retries = 0;
1363 
1364 retry:
1365 	total = len;
1366 	offset = 0;
1367 	do {
1368 		tosend = min3(mgr->max_dpcd_transaction_bytes, 16, total);
1369 
1370 		ret = drm_dp_dpcd_write(mgr->aux, regbase + offset,
1371 					&msg[offset],
1372 					tosend);
1373 		if (ret != tosend) {
1374 			if (ret == -EIO && retries < 5) {
1375 				retries++;
1376 				goto retry;
1377 			}
1378 			DRM_DEBUG_KMS("failed to dpcd write %d %d\n", tosend, ret);
1379 
1380 			return -EIO;
1381 		}
1382 		offset += tosend;
1383 		total -= tosend;
1384 	} while (total > 0);
1385 	return 0;
1386 }
1387 
set_hdr_from_dst_qlock(struct drm_dp_sideband_msg_hdr * hdr,struct drm_dp_sideband_msg_tx * txmsg)1388 static int set_hdr_from_dst_qlock(struct drm_dp_sideband_msg_hdr *hdr,
1389 				  struct drm_dp_sideband_msg_tx *txmsg)
1390 {
1391 	struct drm_dp_mst_branch *mstb = txmsg->dst;
1392 	u8 req_type;
1393 
1394 	/* both msg slots are full */
1395 	if (txmsg->seqno == -1) {
1396 		if (mstb->tx_slots[0] && mstb->tx_slots[1]) {
1397 			DRM_DEBUG_KMS("%s: failed to find slot\n", __func__);
1398 			return -EAGAIN;
1399 		}
1400 		if (mstb->tx_slots[0] == NULL && mstb->tx_slots[1] == NULL) {
1401 			txmsg->seqno = mstb->last_seqno;
1402 			mstb->last_seqno ^= 1;
1403 		} else if (mstb->tx_slots[0] == NULL)
1404 			txmsg->seqno = 0;
1405 		else
1406 			txmsg->seqno = 1;
1407 		mstb->tx_slots[txmsg->seqno] = txmsg;
1408 	}
1409 
1410 	req_type = txmsg->msg[0] & 0x7f;
1411 	if (req_type == DP_CONNECTION_STATUS_NOTIFY ||
1412 		req_type == DP_RESOURCE_STATUS_NOTIFY)
1413 		hdr->broadcast = 1;
1414 	else
1415 		hdr->broadcast = 0;
1416 	hdr->path_msg = txmsg->path_msg;
1417 	hdr->lct = mstb->lct;
1418 	hdr->lcr = mstb->lct - 1;
1419 	if (mstb->lct > 1)
1420 		memcpy(hdr->rad, mstb->rad, mstb->lct / 2);
1421 	hdr->seqno = txmsg->seqno;
1422 	return 0;
1423 }
1424 /*
1425  * process a single block of the next message in the sideband queue
1426  */
process_single_tx_qlock(struct drm_dp_mst_topology_mgr * mgr,struct drm_dp_sideband_msg_tx * txmsg,bool up)1427 static int process_single_tx_qlock(struct drm_dp_mst_topology_mgr *mgr,
1428 				   struct drm_dp_sideband_msg_tx *txmsg,
1429 				   bool up)
1430 {
1431 	u8 chunk[48];
1432 	struct drm_dp_sideband_msg_hdr hdr;
1433 	int len, space, idx, tosend;
1434 	int ret;
1435 
1436 	memset(&hdr, 0, sizeof(struct drm_dp_sideband_msg_hdr));
1437 
1438 	if (txmsg->state == DRM_DP_SIDEBAND_TX_QUEUED) {
1439 		txmsg->seqno = -1;
1440 		txmsg->state = DRM_DP_SIDEBAND_TX_START_SEND;
1441 	}
1442 
1443 	/* make hdr from dst mst - for replies use seqno
1444 	   otherwise assign one */
1445 	ret = set_hdr_from_dst_qlock(&hdr, txmsg);
1446 	if (ret < 0)
1447 		return ret;
1448 
1449 	/* amount left to send in this message */
1450 	len = txmsg->cur_len - txmsg->cur_offset;
1451 
1452 	/* 48 - sideband msg size - 1 byte for data CRC, x header bytes */
1453 	space = 48 - 1 - drm_dp_calc_sb_hdr_size(&hdr);
1454 
1455 	tosend = min(len, space);
1456 	if (len == txmsg->cur_len)
1457 		hdr.somt = 1;
1458 	if (space >= len)
1459 		hdr.eomt = 1;
1460 
1461 
1462 	hdr.msg_len = tosend + 1;
1463 	drm_dp_encode_sideband_msg_hdr(&hdr, chunk, &idx);
1464 	memcpy(&chunk[idx], &txmsg->msg[txmsg->cur_offset], tosend);
1465 	/* add crc at end */
1466 	drm_dp_crc_sideband_chunk_req(&chunk[idx], tosend);
1467 	idx += tosend + 1;
1468 
1469 	ret = drm_dp_send_sideband_msg(mgr, up, chunk, idx);
1470 	if (ret) {
1471 		DRM_DEBUG_KMS("sideband msg failed to send\n");
1472 		return ret;
1473 	}
1474 
1475 	txmsg->cur_offset += tosend;
1476 	if (txmsg->cur_offset == txmsg->cur_len) {
1477 		txmsg->state = DRM_DP_SIDEBAND_TX_SENT;
1478 		return 1;
1479 	}
1480 	return 0;
1481 }
1482 
process_single_down_tx_qlock(struct drm_dp_mst_topology_mgr * mgr)1483 static void process_single_down_tx_qlock(struct drm_dp_mst_topology_mgr *mgr)
1484 {
1485 	struct drm_dp_sideband_msg_tx *txmsg;
1486 	int ret;
1487 
1488 	WARN_ON(!mutex_is_locked(&mgr->qlock));
1489 
1490 	/* construct a chunk from the first msg in the tx_msg queue */
1491 	if (list_empty(&mgr->tx_msg_downq)) {
1492 		mgr->tx_down_in_progress = false;
1493 		return;
1494 	}
1495 	mgr->tx_down_in_progress = true;
1496 
1497 	txmsg = list_first_entry(&mgr->tx_msg_downq, struct drm_dp_sideband_msg_tx, next);
1498 	ret = process_single_tx_qlock(mgr, txmsg, false);
1499 	if (ret == 1) {
1500 		/* txmsg is sent it should be in the slots now */
1501 		list_del(&txmsg->next);
1502 	} else if (ret) {
1503 		DRM_DEBUG_KMS("failed to send msg in q %d\n", ret);
1504 		list_del(&txmsg->next);
1505 		if (txmsg->seqno != -1)
1506 			txmsg->dst->tx_slots[txmsg->seqno] = NULL;
1507 		txmsg->state = DRM_DP_SIDEBAND_TX_TIMEOUT;
1508 		wake_up(&mgr->tx_waitq);
1509 	}
1510 	if (list_empty(&mgr->tx_msg_downq)) {
1511 		mgr->tx_down_in_progress = false;
1512 		return;
1513 	}
1514 }
1515 
1516 /* called holding qlock */
process_single_up_tx_qlock(struct drm_dp_mst_topology_mgr * mgr,struct drm_dp_sideband_msg_tx * txmsg)1517 static void process_single_up_tx_qlock(struct drm_dp_mst_topology_mgr *mgr,
1518 				       struct drm_dp_sideband_msg_tx *txmsg)
1519 {
1520 	int ret;
1521 
1522 	/* construct a chunk from the first msg in the tx_msg queue */
1523 	ret = process_single_tx_qlock(mgr, txmsg, true);
1524 
1525 	if (ret != 1)
1526 		DRM_DEBUG_KMS("failed to send msg in q %d\n", ret);
1527 
1528 	txmsg->dst->tx_slots[txmsg->seqno] = NULL;
1529 }
1530 
drm_dp_queue_down_tx(struct drm_dp_mst_topology_mgr * mgr,struct drm_dp_sideband_msg_tx * txmsg)1531 static void drm_dp_queue_down_tx(struct drm_dp_mst_topology_mgr *mgr,
1532 				 struct drm_dp_sideband_msg_tx *txmsg)
1533 {
1534 	mutex_lock(&mgr->qlock);
1535 	list_add_tail(&txmsg->next, &mgr->tx_msg_downq);
1536 	if (!mgr->tx_down_in_progress)
1537 		process_single_down_tx_qlock(mgr);
1538 	mutex_unlock(&mgr->qlock);
1539 }
1540 
drm_dp_send_link_address(struct drm_dp_mst_topology_mgr * mgr,struct drm_dp_mst_branch * mstb)1541 static void drm_dp_send_link_address(struct drm_dp_mst_topology_mgr *mgr,
1542 				     struct drm_dp_mst_branch *mstb)
1543 {
1544 	int len;
1545 	struct drm_dp_sideband_msg_tx *txmsg;
1546 	int ret;
1547 
1548 	txmsg = kzalloc(sizeof(*txmsg), GFP_KERNEL);
1549 	if (!txmsg)
1550 		return;
1551 
1552 	txmsg->dst = mstb;
1553 	len = build_link_address(txmsg);
1554 
1555 	mstb->link_address_sent = true;
1556 	drm_dp_queue_down_tx(mgr, txmsg);
1557 
1558 	ret = drm_dp_mst_wait_tx_reply(mstb, txmsg);
1559 	if (ret > 0) {
1560 		int i;
1561 
1562 		if (txmsg->reply.reply_type == 1)
1563 			DRM_DEBUG_KMS("link address nak received\n");
1564 		else {
1565 			DRM_DEBUG_KMS("link address reply: %d\n", txmsg->reply.u.link_addr.nports);
1566 			for (i = 0; i < txmsg->reply.u.link_addr.nports; i++) {
1567 				DRM_DEBUG_KMS("port %d: input %d, pdt: %d, pn: %d, dpcd_rev: %02x, mcs: %d, ddps: %d, ldps %d, sdp %d/%d\n", i,
1568 				       txmsg->reply.u.link_addr.ports[i].input_port,
1569 				       txmsg->reply.u.link_addr.ports[i].peer_device_type,
1570 				       txmsg->reply.u.link_addr.ports[i].port_number,
1571 				       txmsg->reply.u.link_addr.ports[i].dpcd_revision,
1572 				       txmsg->reply.u.link_addr.ports[i].mcs,
1573 				       txmsg->reply.u.link_addr.ports[i].ddps,
1574 				       txmsg->reply.u.link_addr.ports[i].legacy_device_plug_status,
1575 				       txmsg->reply.u.link_addr.ports[i].num_sdp_streams,
1576 				       txmsg->reply.u.link_addr.ports[i].num_sdp_stream_sinks);
1577 			}
1578 
1579 			drm_dp_check_mstb_guid(mstb, txmsg->reply.u.link_addr.guid);
1580 
1581 			for (i = 0; i < txmsg->reply.u.link_addr.nports; i++) {
1582 				drm_dp_add_port(mstb, mgr->dev, &txmsg->reply.u.link_addr.ports[i]);
1583 			}
1584 			(*mgr->cbs->hotplug)(mgr);
1585 		}
1586 	} else {
1587 		mstb->link_address_sent = false;
1588 		DRM_DEBUG_KMS("link address failed %d\n", ret);
1589 	}
1590 
1591 	kfree(txmsg);
1592 }
1593 
drm_dp_send_enum_path_resources(struct drm_dp_mst_topology_mgr * mgr,struct drm_dp_mst_branch * mstb,struct drm_dp_mst_port * port)1594 static int drm_dp_send_enum_path_resources(struct drm_dp_mst_topology_mgr *mgr,
1595 					   struct drm_dp_mst_branch *mstb,
1596 					   struct drm_dp_mst_port *port)
1597 {
1598 	int len;
1599 	struct drm_dp_sideband_msg_tx *txmsg;
1600 	int ret;
1601 
1602 	txmsg = kzalloc(sizeof(*txmsg), GFP_KERNEL);
1603 	if (!txmsg)
1604 		return -ENOMEM;
1605 
1606 	txmsg->dst = mstb;
1607 	len = build_enum_path_resources(txmsg, port->port_num);
1608 
1609 	drm_dp_queue_down_tx(mgr, txmsg);
1610 
1611 	ret = drm_dp_mst_wait_tx_reply(mstb, txmsg);
1612 	if (ret > 0) {
1613 		if (txmsg->reply.reply_type == 1)
1614 			DRM_DEBUG_KMS("enum path resources nak received\n");
1615 		else {
1616 			if (port->port_num != txmsg->reply.u.path_resources.port_number)
1617 				DRM_ERROR("got incorrect port in response\n");
1618 			DRM_DEBUG_KMS("enum path resources %d: %d %d\n", txmsg->reply.u.path_resources.port_number, txmsg->reply.u.path_resources.full_payload_bw_number,
1619 			       txmsg->reply.u.path_resources.avail_payload_bw_number);
1620 			port->available_pbn = txmsg->reply.u.path_resources.avail_payload_bw_number;
1621 		}
1622 	}
1623 
1624 	kfree(txmsg);
1625 	return 0;
1626 }
1627 
drm_dp_get_last_connected_port_to_mstb(struct drm_dp_mst_branch * mstb)1628 static struct drm_dp_mst_port *drm_dp_get_last_connected_port_to_mstb(struct drm_dp_mst_branch *mstb)
1629 {
1630 	if (!mstb->port_parent)
1631 		return NULL;
1632 
1633 	if (mstb->port_parent->mstb != mstb)
1634 		return mstb->port_parent;
1635 
1636 	return drm_dp_get_last_connected_port_to_mstb(mstb->port_parent->parent);
1637 }
1638 
drm_dp_get_last_connected_port_and_mstb(struct drm_dp_mst_topology_mgr * mgr,struct drm_dp_mst_branch * mstb,int * port_num)1639 static struct drm_dp_mst_branch *drm_dp_get_last_connected_port_and_mstb(struct drm_dp_mst_topology_mgr *mgr,
1640 									 struct drm_dp_mst_branch *mstb,
1641 									 int *port_num)
1642 {
1643 	struct drm_dp_mst_branch *rmstb = NULL;
1644 	struct drm_dp_mst_port *found_port;
1645 	mutex_lock(&mgr->lock);
1646 	if (mgr->mst_primary) {
1647 		found_port = drm_dp_get_last_connected_port_to_mstb(mstb);
1648 
1649 		if (found_port) {
1650 			rmstb = found_port->parent;
1651 			kref_get(&rmstb->kref);
1652 			*port_num = found_port->port_num;
1653 		}
1654 	}
1655 	mutex_unlock(&mgr->lock);
1656 	return rmstb;
1657 }
1658 
drm_dp_payload_send_msg(struct drm_dp_mst_topology_mgr * mgr,struct drm_dp_mst_port * port,int id,int pbn)1659 static int drm_dp_payload_send_msg(struct drm_dp_mst_topology_mgr *mgr,
1660 				   struct drm_dp_mst_port *port,
1661 				   int id,
1662 				   int pbn)
1663 {
1664 	struct drm_dp_sideband_msg_tx *txmsg;
1665 	struct drm_dp_mst_branch *mstb;
1666 	int len, ret, port_num;
1667 
1668 	port = drm_dp_get_validated_port_ref(mgr, port);
1669 	if (!port)
1670 		return -EINVAL;
1671 
1672 	port_num = port->port_num;
1673 	mstb = drm_dp_get_validated_mstb_ref(mgr, port->parent);
1674 	if (!mstb) {
1675 		mstb = drm_dp_get_last_connected_port_and_mstb(mgr, port->parent, &port_num);
1676 
1677 		if (!mstb) {
1678 			drm_dp_put_port(port);
1679 			return -EINVAL;
1680 		}
1681 	}
1682 
1683 	txmsg = kzalloc(sizeof(*txmsg), GFP_KERNEL);
1684 	if (!txmsg) {
1685 		ret = -ENOMEM;
1686 		goto fail_put;
1687 	}
1688 
1689 	txmsg->dst = mstb;
1690 	len = build_allocate_payload(txmsg, port_num,
1691 				     id,
1692 				     pbn);
1693 
1694 	drm_dp_queue_down_tx(mgr, txmsg);
1695 
1696 	ret = drm_dp_mst_wait_tx_reply(mstb, txmsg);
1697 	if (ret > 0) {
1698 		if (txmsg->reply.reply_type == 1) {
1699 			ret = -EINVAL;
1700 		} else
1701 			ret = 0;
1702 	}
1703 	kfree(txmsg);
1704 fail_put:
1705 	drm_dp_put_mst_branch_device(mstb);
1706 	drm_dp_put_port(port);
1707 	return ret;
1708 }
1709 
drm_dp_create_payload_step1(struct drm_dp_mst_topology_mgr * mgr,int id,struct drm_dp_payload * payload)1710 static int drm_dp_create_payload_step1(struct drm_dp_mst_topology_mgr *mgr,
1711 				       int id,
1712 				       struct drm_dp_payload *payload)
1713 {
1714 	int ret;
1715 
1716 	ret = drm_dp_dpcd_write_payload(mgr, id, payload);
1717 	if (ret < 0) {
1718 		payload->payload_state = 0;
1719 		return ret;
1720 	}
1721 	payload->payload_state = DP_PAYLOAD_LOCAL;
1722 	return 0;
1723 }
1724 
drm_dp_create_payload_step2(struct drm_dp_mst_topology_mgr * mgr,struct drm_dp_mst_port * port,int id,struct drm_dp_payload * payload)1725 static int drm_dp_create_payload_step2(struct drm_dp_mst_topology_mgr *mgr,
1726 				       struct drm_dp_mst_port *port,
1727 				       int id,
1728 				       struct drm_dp_payload *payload)
1729 {
1730 	int ret;
1731 	ret = drm_dp_payload_send_msg(mgr, port, id, port->vcpi.pbn);
1732 	if (ret < 0)
1733 		return ret;
1734 	payload->payload_state = DP_PAYLOAD_REMOTE;
1735 	return ret;
1736 }
1737 
drm_dp_destroy_payload_step1(struct drm_dp_mst_topology_mgr * mgr,struct drm_dp_mst_port * port,int id,struct drm_dp_payload * payload)1738 static int drm_dp_destroy_payload_step1(struct drm_dp_mst_topology_mgr *mgr,
1739 					struct drm_dp_mst_port *port,
1740 					int id,
1741 					struct drm_dp_payload *payload)
1742 {
1743 	DRM_DEBUG_KMS("\n");
1744 	/* its okay for these to fail */
1745 	if (port) {
1746 		drm_dp_payload_send_msg(mgr, port, id, 0);
1747 	}
1748 
1749 	drm_dp_dpcd_write_payload(mgr, id, payload);
1750 	payload->payload_state = DP_PAYLOAD_DELETE_LOCAL;
1751 	return 0;
1752 }
1753 
drm_dp_destroy_payload_step2(struct drm_dp_mst_topology_mgr * mgr,int id,struct drm_dp_payload * payload)1754 static int drm_dp_destroy_payload_step2(struct drm_dp_mst_topology_mgr *mgr,
1755 					int id,
1756 					struct drm_dp_payload *payload)
1757 {
1758 	payload->payload_state = 0;
1759 	return 0;
1760 }
1761 
1762 /**
1763  * drm_dp_update_payload_part1() - Execute payload update part 1
1764  * @mgr: manager to use.
1765  *
1766  * This iterates over all proposed virtual channels, and tries to
1767  * allocate space in the link for them. For 0->slots transitions,
1768  * this step just writes the VCPI to the MST device. For slots->0
1769  * transitions, this writes the updated VCPIs and removes the
1770  * remote VC payloads.
1771  *
1772  * after calling this the driver should generate ACT and payload
1773  * packets.
1774  */
drm_dp_update_payload_part1(struct drm_dp_mst_topology_mgr * mgr)1775 int drm_dp_update_payload_part1(struct drm_dp_mst_topology_mgr *mgr)
1776 {
1777 	int i, j;
1778 	int cur_slots = 1;
1779 	struct drm_dp_payload req_payload;
1780 	struct drm_dp_mst_port *port;
1781 
1782 	mutex_lock(&mgr->payload_lock);
1783 	for (i = 0; i < mgr->max_payloads; i++) {
1784 		/* solve the current payloads - compare to the hw ones
1785 		   - update the hw view */
1786 		req_payload.start_slot = cur_slots;
1787 		if (mgr->proposed_vcpis[i]) {
1788 			port = container_of(mgr->proposed_vcpis[i], struct drm_dp_mst_port, vcpi);
1789 			port = drm_dp_get_validated_port_ref(mgr, port);
1790 			if (!port) {
1791 				mutex_unlock(&mgr->payload_lock);
1792 				return -EINVAL;
1793 			}
1794 			req_payload.num_slots = mgr->proposed_vcpis[i]->num_slots;
1795 		} else {
1796 			port = NULL;
1797 			req_payload.num_slots = 0;
1798 		}
1799 
1800 		if (mgr->payloads[i].start_slot != req_payload.start_slot) {
1801 			mgr->payloads[i].start_slot = req_payload.start_slot;
1802 		}
1803 		/* work out what is required to happen with this payload */
1804 		if (mgr->payloads[i].num_slots != req_payload.num_slots) {
1805 
1806 			/* need to push an update for this payload */
1807 			if (req_payload.num_slots) {
1808 				drm_dp_create_payload_step1(mgr, mgr->proposed_vcpis[i]->vcpi, &req_payload);
1809 				mgr->payloads[i].num_slots = req_payload.num_slots;
1810 			} else if (mgr->payloads[i].num_slots) {
1811 				mgr->payloads[i].num_slots = 0;
1812 				drm_dp_destroy_payload_step1(mgr, port, port->vcpi.vcpi, &mgr->payloads[i]);
1813 				req_payload.payload_state = mgr->payloads[i].payload_state;
1814 				mgr->payloads[i].start_slot = 0;
1815 			}
1816 			mgr->payloads[i].payload_state = req_payload.payload_state;
1817 		}
1818 		cur_slots += req_payload.num_slots;
1819 
1820 		if (port)
1821 			drm_dp_put_port(port);
1822 	}
1823 
1824 	for (i = 0; i < mgr->max_payloads; i++) {
1825 		if (mgr->payloads[i].payload_state == DP_PAYLOAD_DELETE_LOCAL) {
1826 			DRM_DEBUG_KMS("removing payload %d\n", i);
1827 			for (j = i; j < mgr->max_payloads - 1; j++) {
1828 				memcpy(&mgr->payloads[j], &mgr->payloads[j + 1], sizeof(struct drm_dp_payload));
1829 				mgr->proposed_vcpis[j] = mgr->proposed_vcpis[j + 1];
1830 				if (mgr->proposed_vcpis[j] && mgr->proposed_vcpis[j]->num_slots) {
1831 					set_bit(j + 1, &mgr->payload_mask);
1832 				} else {
1833 					clear_bit(j + 1, &mgr->payload_mask);
1834 				}
1835 			}
1836 			memset(&mgr->payloads[mgr->max_payloads - 1], 0, sizeof(struct drm_dp_payload));
1837 			mgr->proposed_vcpis[mgr->max_payloads - 1] = NULL;
1838 			clear_bit(mgr->max_payloads, &mgr->payload_mask);
1839 
1840 		}
1841 	}
1842 	mutex_unlock(&mgr->payload_lock);
1843 
1844 	return 0;
1845 }
1846 EXPORT_SYMBOL(drm_dp_update_payload_part1);
1847 
1848 /**
1849  * drm_dp_update_payload_part2() - Execute payload update part 2
1850  * @mgr: manager to use.
1851  *
1852  * This iterates over all proposed virtual channels, and tries to
1853  * allocate space in the link for them. For 0->slots transitions,
1854  * this step writes the remote VC payload commands. For slots->0
1855  * this just resets some internal state.
1856  */
drm_dp_update_payload_part2(struct drm_dp_mst_topology_mgr * mgr)1857 int drm_dp_update_payload_part2(struct drm_dp_mst_topology_mgr *mgr)
1858 {
1859 	struct drm_dp_mst_port *port;
1860 	int i;
1861 	int ret = 0;
1862 	mutex_lock(&mgr->payload_lock);
1863 	for (i = 0; i < mgr->max_payloads; i++) {
1864 
1865 		if (!mgr->proposed_vcpis[i])
1866 			continue;
1867 
1868 		port = container_of(mgr->proposed_vcpis[i], struct drm_dp_mst_port, vcpi);
1869 
1870 		DRM_DEBUG_KMS("payload %d %d\n", i, mgr->payloads[i].payload_state);
1871 		if (mgr->payloads[i].payload_state == DP_PAYLOAD_LOCAL) {
1872 			ret = drm_dp_create_payload_step2(mgr, port, mgr->proposed_vcpis[i]->vcpi, &mgr->payloads[i]);
1873 		} else if (mgr->payloads[i].payload_state == DP_PAYLOAD_DELETE_LOCAL) {
1874 			ret = drm_dp_destroy_payload_step2(mgr, mgr->proposed_vcpis[i]->vcpi, &mgr->payloads[i]);
1875 		}
1876 		if (ret) {
1877 			mutex_unlock(&mgr->payload_lock);
1878 			return ret;
1879 		}
1880 	}
1881 	mutex_unlock(&mgr->payload_lock);
1882 	return 0;
1883 }
1884 EXPORT_SYMBOL(drm_dp_update_payload_part2);
1885 
1886 #if 0 /* unused as of yet */
1887 static int drm_dp_send_dpcd_read(struct drm_dp_mst_topology_mgr *mgr,
1888 				 struct drm_dp_mst_port *port,
1889 				 int offset, int size)
1890 {
1891 	int len;
1892 	struct drm_dp_sideband_msg_tx *txmsg;
1893 
1894 	txmsg = kzalloc(sizeof(*txmsg), GFP_KERNEL);
1895 	if (!txmsg)
1896 		return -ENOMEM;
1897 
1898 	len = build_dpcd_read(txmsg, port->port_num, 0, 8);
1899 	txmsg->dst = port->parent;
1900 
1901 	drm_dp_queue_down_tx(mgr, txmsg);
1902 
1903 	return 0;
1904 }
1905 #endif
1906 
drm_dp_send_dpcd_write(struct drm_dp_mst_topology_mgr * mgr,struct drm_dp_mst_port * port,int offset,int size,u8 * bytes)1907 static int drm_dp_send_dpcd_write(struct drm_dp_mst_topology_mgr *mgr,
1908 				  struct drm_dp_mst_port *port,
1909 				  int offset, int size, u8 *bytes)
1910 {
1911 	int len;
1912 	int ret;
1913 	struct drm_dp_sideband_msg_tx *txmsg;
1914 	struct drm_dp_mst_branch *mstb;
1915 
1916 	mstb = drm_dp_get_validated_mstb_ref(mgr, port->parent);
1917 	if (!mstb)
1918 		return -EINVAL;
1919 
1920 	txmsg = kzalloc(sizeof(*txmsg), GFP_KERNEL);
1921 	if (!txmsg) {
1922 		ret = -ENOMEM;
1923 		goto fail_put;
1924 	}
1925 
1926 	len = build_dpcd_write(txmsg, port->port_num, offset, size, bytes);
1927 	txmsg->dst = mstb;
1928 
1929 	drm_dp_queue_down_tx(mgr, txmsg);
1930 
1931 	ret = drm_dp_mst_wait_tx_reply(mstb, txmsg);
1932 	if (ret > 0) {
1933 		if (txmsg->reply.reply_type == 1) {
1934 			ret = -EINVAL;
1935 		} else
1936 			ret = 0;
1937 	}
1938 	kfree(txmsg);
1939 fail_put:
1940 	drm_dp_put_mst_branch_device(mstb);
1941 	return ret;
1942 }
1943 
drm_dp_encode_up_ack_reply(struct drm_dp_sideband_msg_tx * msg,u8 req_type)1944 static int drm_dp_encode_up_ack_reply(struct drm_dp_sideband_msg_tx *msg, u8 req_type)
1945 {
1946 	struct drm_dp_sideband_msg_reply_body reply;
1947 
1948 	reply.reply_type = 1;
1949 	reply.req_type = req_type;
1950 	drm_dp_encode_sideband_reply(&reply, msg);
1951 	return 0;
1952 }
1953 
drm_dp_send_up_ack_reply(struct drm_dp_mst_topology_mgr * mgr,struct drm_dp_mst_branch * mstb,int req_type,int seqno,bool broadcast)1954 static int drm_dp_send_up_ack_reply(struct drm_dp_mst_topology_mgr *mgr,
1955 				    struct drm_dp_mst_branch *mstb,
1956 				    int req_type, int seqno, bool broadcast)
1957 {
1958 	struct drm_dp_sideband_msg_tx *txmsg;
1959 
1960 	txmsg = kzalloc(sizeof(*txmsg), GFP_KERNEL);
1961 	if (!txmsg)
1962 		return -ENOMEM;
1963 
1964 	txmsg->dst = mstb;
1965 	txmsg->seqno = seqno;
1966 	drm_dp_encode_up_ack_reply(txmsg, req_type);
1967 
1968 	mutex_lock(&mgr->qlock);
1969 
1970 	process_single_up_tx_qlock(mgr, txmsg);
1971 
1972 	mutex_unlock(&mgr->qlock);
1973 
1974 	kfree(txmsg);
1975 	return 0;
1976 }
1977 
drm_dp_get_vc_payload_bw(int dp_link_bw,int dp_link_count,int * out)1978 static bool drm_dp_get_vc_payload_bw(int dp_link_bw,
1979 				     int dp_link_count,
1980 				     int *out)
1981 {
1982 	switch (dp_link_bw) {
1983 	default:
1984 		DRM_DEBUG_KMS("invalid link bandwidth in DPCD: %x (link count: %d)\n",
1985 			      dp_link_bw, dp_link_count);
1986 		return false;
1987 
1988 	case DP_LINK_BW_1_62:
1989 		*out = 3 * dp_link_count;
1990 		break;
1991 	case DP_LINK_BW_2_7:
1992 		*out = 5 * dp_link_count;
1993 		break;
1994 	case DP_LINK_BW_5_4:
1995 		*out = 10 * dp_link_count;
1996 		break;
1997 	}
1998 	return true;
1999 }
2000 
2001 /**
2002  * drm_dp_mst_topology_mgr_set_mst() - Set the MST state for a topology manager
2003  * @mgr: manager to set state for
2004  * @mst_state: true to enable MST on this connector - false to disable.
2005  *
2006  * This is called by the driver when it detects an MST capable device plugged
2007  * into a DP MST capable port, or when a DP MST capable device is unplugged.
2008  */
drm_dp_mst_topology_mgr_set_mst(struct drm_dp_mst_topology_mgr * mgr,bool mst_state)2009 int drm_dp_mst_topology_mgr_set_mst(struct drm_dp_mst_topology_mgr *mgr, bool mst_state)
2010 {
2011 	int ret = 0;
2012 	struct drm_dp_mst_branch *mstb = NULL;
2013 
2014 	mutex_lock(&mgr->lock);
2015 	if (mst_state == mgr->mst_state)
2016 		goto out_unlock;
2017 
2018 	mgr->mst_state = mst_state;
2019 	/* set the device into MST mode */
2020 	if (mst_state) {
2021 		WARN_ON(mgr->mst_primary);
2022 
2023 		/* get dpcd info */
2024 		ret = drm_dp_dpcd_read(mgr->aux, DP_DPCD_REV, mgr->dpcd, DP_RECEIVER_CAP_SIZE);
2025 		if (ret != DP_RECEIVER_CAP_SIZE) {
2026 			DRM_DEBUG_KMS("failed to read DPCD\n");
2027 			goto out_unlock;
2028 		}
2029 
2030 		if (!drm_dp_get_vc_payload_bw(mgr->dpcd[1],
2031 					      mgr->dpcd[2] & DP_MAX_LANE_COUNT_MASK,
2032 					      &mgr->pbn_div)) {
2033 			ret = -EINVAL;
2034 			goto out_unlock;
2035 		}
2036 
2037 		mgr->total_pbn = 2560;
2038 		mgr->total_slots = DIV_ROUND_UP(mgr->total_pbn, mgr->pbn_div);
2039 		mgr->avail_slots = mgr->total_slots;
2040 
2041 		/* add initial branch device at LCT 1 */
2042 		mstb = drm_dp_add_mst_branch_device(1, NULL);
2043 		if (mstb == NULL) {
2044 			ret = -ENOMEM;
2045 			goto out_unlock;
2046 		}
2047 		mstb->mgr = mgr;
2048 
2049 		/* give this the main reference */
2050 		mgr->mst_primary = mstb;
2051 		kref_get(&mgr->mst_primary->kref);
2052 
2053 		ret = drm_dp_dpcd_writeb(mgr->aux, DP_MSTM_CTRL,
2054 							 DP_MST_EN | DP_UP_REQ_EN | DP_UPSTREAM_IS_SRC);
2055 		if (ret < 0) {
2056 			goto out_unlock;
2057 		}
2058 
2059 		{
2060 			struct drm_dp_payload reset_pay;
2061 			reset_pay.start_slot = 0;
2062 			reset_pay.num_slots = 0x3f;
2063 			drm_dp_dpcd_write_payload(mgr, 0, &reset_pay);
2064 		}
2065 
2066 		queue_work(system_long_wq, &mgr->work);
2067 
2068 		ret = 0;
2069 	} else {
2070 		/* disable MST on the device */
2071 		mstb = mgr->mst_primary;
2072 		mgr->mst_primary = NULL;
2073 		/* this can fail if the device is gone */
2074 		drm_dp_dpcd_writeb(mgr->aux, DP_MSTM_CTRL, 0);
2075 		ret = 0;
2076 		memset(mgr->payloads, 0, mgr->max_payloads * sizeof(struct drm_dp_payload));
2077 		mgr->payload_mask = 0;
2078 		set_bit(0, &mgr->payload_mask);
2079 		mgr->vcpi_mask = 0;
2080 	}
2081 
2082 out_unlock:
2083 	mutex_unlock(&mgr->lock);
2084 	if (mstb)
2085 		drm_dp_put_mst_branch_device(mstb);
2086 	return ret;
2087 
2088 }
2089 EXPORT_SYMBOL(drm_dp_mst_topology_mgr_set_mst);
2090 
2091 /**
2092  * drm_dp_mst_topology_mgr_suspend() - suspend the MST manager
2093  * @mgr: manager to suspend
2094  *
2095  * This function tells the MST device that we can't handle UP messages
2096  * anymore. This should stop it from sending any since we are suspended.
2097  */
drm_dp_mst_topology_mgr_suspend(struct drm_dp_mst_topology_mgr * mgr)2098 void drm_dp_mst_topology_mgr_suspend(struct drm_dp_mst_topology_mgr *mgr)
2099 {
2100 	mutex_lock(&mgr->lock);
2101 	drm_dp_dpcd_writeb(mgr->aux, DP_MSTM_CTRL,
2102 			   DP_MST_EN | DP_UPSTREAM_IS_SRC);
2103 	mutex_unlock(&mgr->lock);
2104 	flush_work(&mgr->work);
2105 	flush_work(&mgr->destroy_connector_work);
2106 }
2107 EXPORT_SYMBOL(drm_dp_mst_topology_mgr_suspend);
2108 
2109 /**
2110  * drm_dp_mst_topology_mgr_resume() - resume the MST manager
2111  * @mgr: manager to resume
2112  *
2113  * This will fetch DPCD and see if the device is still there,
2114  * if it is, it will rewrite the MSTM control bits, and return.
2115  *
2116  * if the device fails this returns -1, and the driver should do
2117  * a full MST reprobe, in case we were undocked.
2118  */
drm_dp_mst_topology_mgr_resume(struct drm_dp_mst_topology_mgr * mgr)2119 int drm_dp_mst_topology_mgr_resume(struct drm_dp_mst_topology_mgr *mgr)
2120 {
2121 	int ret = 0;
2122 
2123 	mutex_lock(&mgr->lock);
2124 
2125 	if (mgr->mst_primary) {
2126 		int sret;
2127 		u8 guid[16];
2128 
2129 		sret = drm_dp_dpcd_read(mgr->aux, DP_DPCD_REV, mgr->dpcd, DP_RECEIVER_CAP_SIZE);
2130 		if (sret != DP_RECEIVER_CAP_SIZE) {
2131 			DRM_DEBUG_KMS("dpcd read failed - undocked during suspend?\n");
2132 			ret = -1;
2133 			goto out_unlock;
2134 		}
2135 
2136 		ret = drm_dp_dpcd_writeb(mgr->aux, DP_MSTM_CTRL,
2137 					 DP_MST_EN | DP_UP_REQ_EN | DP_UPSTREAM_IS_SRC);
2138 		if (ret < 0) {
2139 			DRM_DEBUG_KMS("mst write failed - undocked during suspend?\n");
2140 			ret = -1;
2141 			goto out_unlock;
2142 		}
2143 
2144 		/* Some hubs forget their guids after they resume */
2145 		sret = drm_dp_dpcd_read(mgr->aux, DP_GUID, guid, 16);
2146 		if (sret != 16) {
2147 			DRM_DEBUG_KMS("dpcd read failed - undocked during suspend?\n");
2148 			ret = -1;
2149 			goto out_unlock;
2150 		}
2151 		drm_dp_check_mstb_guid(mgr->mst_primary, guid);
2152 
2153 		ret = 0;
2154 	} else
2155 		ret = -1;
2156 
2157 out_unlock:
2158 	mutex_unlock(&mgr->lock);
2159 	return ret;
2160 }
2161 EXPORT_SYMBOL(drm_dp_mst_topology_mgr_resume);
2162 
drm_dp_get_one_sb_msg(struct drm_dp_mst_topology_mgr * mgr,bool up)2163 static void drm_dp_get_one_sb_msg(struct drm_dp_mst_topology_mgr *mgr, bool up)
2164 {
2165 	int len;
2166 	u8 replyblock[32];
2167 	int replylen, origlen, curreply;
2168 	int ret;
2169 	struct drm_dp_sideband_msg_rx *msg;
2170 	int basereg = up ? DP_SIDEBAND_MSG_UP_REQ_BASE : DP_SIDEBAND_MSG_DOWN_REP_BASE;
2171 	msg = up ? &mgr->up_req_recv : &mgr->down_rep_recv;
2172 
2173 	len = min(mgr->max_dpcd_transaction_bytes, 16);
2174 	ret = drm_dp_dpcd_read(mgr->aux, basereg,
2175 			       replyblock, len);
2176 	if (ret != len) {
2177 		DRM_DEBUG_KMS("failed to read DPCD down rep %d %d\n", len, ret);
2178 		return;
2179 	}
2180 	ret = drm_dp_sideband_msg_build(msg, replyblock, len, true);
2181 	if (!ret) {
2182 		DRM_DEBUG_KMS("sideband msg build failed %d\n", replyblock[0]);
2183 		return;
2184 	}
2185 	replylen = msg->curchunk_len + msg->curchunk_hdrlen;
2186 
2187 	origlen = replylen;
2188 	replylen -= len;
2189 	curreply = len;
2190 	while (replylen > 0) {
2191 		len = min3(replylen, mgr->max_dpcd_transaction_bytes, 16);
2192 		ret = drm_dp_dpcd_read(mgr->aux, basereg + curreply,
2193 				    replyblock, len);
2194 		if (ret != len) {
2195 			DRM_DEBUG_KMS("failed to read a chunk\n");
2196 		}
2197 		ret = drm_dp_sideband_msg_build(msg, replyblock, len, false);
2198 		if (ret == false)
2199 			DRM_DEBUG_KMS("failed to build sideband msg\n");
2200 		curreply += len;
2201 		replylen -= len;
2202 	}
2203 }
2204 
drm_dp_mst_handle_down_rep(struct drm_dp_mst_topology_mgr * mgr)2205 static int drm_dp_mst_handle_down_rep(struct drm_dp_mst_topology_mgr *mgr)
2206 {
2207 	int ret = 0;
2208 
2209 	drm_dp_get_one_sb_msg(mgr, false);
2210 
2211 	if (mgr->down_rep_recv.have_eomt) {
2212 		struct drm_dp_sideband_msg_tx *txmsg;
2213 		struct drm_dp_mst_branch *mstb;
2214 		int slot = -1;
2215 		mstb = drm_dp_get_mst_branch_device(mgr,
2216 						    mgr->down_rep_recv.initial_hdr.lct,
2217 						    mgr->down_rep_recv.initial_hdr.rad);
2218 
2219 		if (!mstb) {
2220 			DRM_DEBUG_KMS("Got MST reply from unknown device %d\n", mgr->down_rep_recv.initial_hdr.lct);
2221 			memset(&mgr->down_rep_recv, 0, sizeof(struct drm_dp_sideband_msg_rx));
2222 			return 0;
2223 		}
2224 
2225 		/* find the message */
2226 		slot = mgr->down_rep_recv.initial_hdr.seqno;
2227 		mutex_lock(&mgr->qlock);
2228 		txmsg = mstb->tx_slots[slot];
2229 		/* remove from slots */
2230 		mutex_unlock(&mgr->qlock);
2231 
2232 		if (!txmsg) {
2233 			DRM_DEBUG_KMS("Got MST reply with no msg %p %d %d %02x %02x\n",
2234 			       mstb,
2235 			       mgr->down_rep_recv.initial_hdr.seqno,
2236 			       mgr->down_rep_recv.initial_hdr.lct,
2237 				      mgr->down_rep_recv.initial_hdr.rad[0],
2238 				      mgr->down_rep_recv.msg[0]);
2239 			drm_dp_put_mst_branch_device(mstb);
2240 			memset(&mgr->down_rep_recv, 0, sizeof(struct drm_dp_sideband_msg_rx));
2241 			return 0;
2242 		}
2243 
2244 		drm_dp_sideband_parse_reply(&mgr->down_rep_recv, &txmsg->reply);
2245 		if (txmsg->reply.reply_type == 1) {
2246 			DRM_DEBUG_KMS("Got NAK reply: req 0x%02x, reason 0x%02x, nak data 0x%02x\n", txmsg->reply.req_type, txmsg->reply.u.nak.reason, txmsg->reply.u.nak.nak_data);
2247 		}
2248 
2249 		memset(&mgr->down_rep_recv, 0, sizeof(struct drm_dp_sideband_msg_rx));
2250 		drm_dp_put_mst_branch_device(mstb);
2251 
2252 		mutex_lock(&mgr->qlock);
2253 		txmsg->state = DRM_DP_SIDEBAND_TX_RX;
2254 		mstb->tx_slots[slot] = NULL;
2255 		mutex_unlock(&mgr->qlock);
2256 
2257 		wake_up(&mgr->tx_waitq);
2258 	}
2259 	return ret;
2260 }
2261 
drm_dp_mst_handle_up_req(struct drm_dp_mst_topology_mgr * mgr)2262 static int drm_dp_mst_handle_up_req(struct drm_dp_mst_topology_mgr *mgr)
2263 {
2264 	int ret = 0;
2265 	drm_dp_get_one_sb_msg(mgr, true);
2266 
2267 	if (mgr->up_req_recv.have_eomt) {
2268 		struct drm_dp_sideband_msg_req_body msg;
2269 		struct drm_dp_mst_branch *mstb = NULL;
2270 		bool seqno;
2271 
2272 		if (!mgr->up_req_recv.initial_hdr.broadcast) {
2273 			mstb = drm_dp_get_mst_branch_device(mgr,
2274 							    mgr->up_req_recv.initial_hdr.lct,
2275 							    mgr->up_req_recv.initial_hdr.rad);
2276 			if (!mstb) {
2277 				DRM_DEBUG_KMS("Got MST reply from unknown device %d\n", mgr->up_req_recv.initial_hdr.lct);
2278 				memset(&mgr->up_req_recv, 0, sizeof(struct drm_dp_sideband_msg_rx));
2279 				return 0;
2280 			}
2281 		}
2282 
2283 		seqno = mgr->up_req_recv.initial_hdr.seqno;
2284 		drm_dp_sideband_parse_req(&mgr->up_req_recv, &msg);
2285 
2286 		if (msg.req_type == DP_CONNECTION_STATUS_NOTIFY) {
2287 			drm_dp_send_up_ack_reply(mgr, mgr->mst_primary, msg.req_type, seqno, false);
2288 
2289 			if (!mstb)
2290 				mstb = drm_dp_get_mst_branch_device_by_guid(mgr, msg.u.conn_stat.guid);
2291 
2292 			if (!mstb) {
2293 				DRM_DEBUG_KMS("Got MST reply from unknown device %d\n", mgr->up_req_recv.initial_hdr.lct);
2294 				memset(&mgr->up_req_recv, 0, sizeof(struct drm_dp_sideband_msg_rx));
2295 				return 0;
2296 			}
2297 
2298 			drm_dp_update_port(mstb, &msg.u.conn_stat);
2299 
2300 			DRM_DEBUG_KMS("Got CSN: pn: %d ldps:%d ddps: %d mcs: %d ip: %d pdt: %d\n", msg.u.conn_stat.port_number, msg.u.conn_stat.legacy_device_plug_status, msg.u.conn_stat.displayport_device_plug_status, msg.u.conn_stat.message_capability_status, msg.u.conn_stat.input_port, msg.u.conn_stat.peer_device_type);
2301 			(*mgr->cbs->hotplug)(mgr);
2302 
2303 		} else if (msg.req_type == DP_RESOURCE_STATUS_NOTIFY) {
2304 			drm_dp_send_up_ack_reply(mgr, mgr->mst_primary, msg.req_type, seqno, false);
2305 			if (!mstb)
2306 				mstb = drm_dp_get_mst_branch_device_by_guid(mgr, msg.u.resource_stat.guid);
2307 
2308 			if (!mstb) {
2309 				DRM_DEBUG_KMS("Got MST reply from unknown device %d\n", mgr->up_req_recv.initial_hdr.lct);
2310 				memset(&mgr->up_req_recv, 0, sizeof(struct drm_dp_sideband_msg_rx));
2311 				return 0;
2312 			}
2313 
2314 			DRM_DEBUG_KMS("Got RSN: pn: %d avail_pbn %d\n", msg.u.resource_stat.port_number, msg.u.resource_stat.available_pbn);
2315 		}
2316 
2317 		drm_dp_put_mst_branch_device(mstb);
2318 		memset(&mgr->up_req_recv, 0, sizeof(struct drm_dp_sideband_msg_rx));
2319 	}
2320 	return ret;
2321 }
2322 
2323 /**
2324  * drm_dp_mst_hpd_irq() - MST hotplug IRQ notify
2325  * @mgr: manager to notify irq for.
2326  * @esi: 4 bytes from SINK_COUNT_ESI
2327  * @handled: whether the hpd interrupt was consumed or not
2328  *
2329  * This should be called from the driver when it detects a short IRQ,
2330  * along with the value of the DEVICE_SERVICE_IRQ_VECTOR_ESI0. The
2331  * topology manager will process the sideband messages received as a result
2332  * of this.
2333  */
drm_dp_mst_hpd_irq(struct drm_dp_mst_topology_mgr * mgr,u8 * esi,bool * handled)2334 int drm_dp_mst_hpd_irq(struct drm_dp_mst_topology_mgr *mgr, u8 *esi, bool *handled)
2335 {
2336 	int ret = 0;
2337 	int sc;
2338 	*handled = false;
2339 	sc = esi[0] & 0x3f;
2340 
2341 	if (sc != mgr->sink_count) {
2342 		mgr->sink_count = sc;
2343 		*handled = true;
2344 	}
2345 
2346 	if (esi[1] & DP_DOWN_REP_MSG_RDY) {
2347 		ret = drm_dp_mst_handle_down_rep(mgr);
2348 		*handled = true;
2349 	}
2350 
2351 	if (esi[1] & DP_UP_REQ_MSG_RDY) {
2352 		ret |= drm_dp_mst_handle_up_req(mgr);
2353 		*handled = true;
2354 	}
2355 
2356 	drm_dp_mst_kick_tx(mgr);
2357 	return ret;
2358 }
2359 EXPORT_SYMBOL(drm_dp_mst_hpd_irq);
2360 
2361 /**
2362  * drm_dp_mst_detect_port() - get connection status for an MST port
2363  * @mgr: manager for this port
2364  * @port: unverified pointer to a port
2365  *
2366  * This returns the current connection state for a port. It validates the
2367  * port pointer still exists so the caller doesn't require a reference
2368  */
drm_dp_mst_detect_port(struct drm_connector * connector,struct drm_dp_mst_topology_mgr * mgr,struct drm_dp_mst_port * port)2369 enum drm_connector_status drm_dp_mst_detect_port(struct drm_connector *connector,
2370 						 struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port)
2371 {
2372 	enum drm_connector_status status = connector_status_disconnected;
2373 
2374 	/* we need to search for the port in the mgr in case its gone */
2375 	port = drm_dp_get_validated_port_ref(mgr, port);
2376 	if (!port)
2377 		return connector_status_disconnected;
2378 
2379 	if (!port->ddps)
2380 		goto out;
2381 
2382 	switch (port->pdt) {
2383 	case DP_PEER_DEVICE_NONE:
2384 	case DP_PEER_DEVICE_MST_BRANCHING:
2385 		break;
2386 
2387 	case DP_PEER_DEVICE_SST_SINK:
2388 		status = connector_status_connected;
2389 		/* for logical ports - cache the EDID */
2390 		if (port->port_num >= 8 && !port->cached_edid) {
2391 			port->cached_edid = drm_get_edid(connector, &port->aux.ddc);
2392 		}
2393 		break;
2394 	case DP_PEER_DEVICE_DP_LEGACY_CONV:
2395 		if (port->ldps)
2396 			status = connector_status_connected;
2397 		break;
2398 	}
2399 out:
2400 	drm_dp_put_port(port);
2401 	return status;
2402 }
2403 EXPORT_SYMBOL(drm_dp_mst_detect_port);
2404 
2405 /**
2406  * drm_dp_mst_get_edid() - get EDID for an MST port
2407  * @connector: toplevel connector to get EDID for
2408  * @mgr: manager for this port
2409  * @port: unverified pointer to a port.
2410  *
2411  * This returns an EDID for the port connected to a connector,
2412  * It validates the pointer still exists so the caller doesn't require a
2413  * reference.
2414  */
drm_dp_mst_get_edid(struct drm_connector * connector,struct drm_dp_mst_topology_mgr * mgr,struct drm_dp_mst_port * port)2415 struct edid *drm_dp_mst_get_edid(struct drm_connector *connector, struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port)
2416 {
2417 	struct edid *edid = NULL;
2418 
2419 	/* we need to search for the port in the mgr in case its gone */
2420 	port = drm_dp_get_validated_port_ref(mgr, port);
2421 	if (!port)
2422 		return NULL;
2423 
2424 	if (port->cached_edid)
2425 		edid = drm_edid_duplicate(port->cached_edid);
2426 	else {
2427 		edid = drm_get_edid(connector, &port->aux.ddc);
2428 		drm_mode_connector_set_tile_property(connector);
2429 	}
2430 	drm_dp_put_port(port);
2431 	return edid;
2432 }
2433 EXPORT_SYMBOL(drm_dp_mst_get_edid);
2434 
2435 /**
2436  * drm_dp_find_vcpi_slots() - find slots for this PBN value
2437  * @mgr: manager to use
2438  * @pbn: payload bandwidth to convert into slots.
2439  */
drm_dp_find_vcpi_slots(struct drm_dp_mst_topology_mgr * mgr,int pbn)2440 int drm_dp_find_vcpi_slots(struct drm_dp_mst_topology_mgr *mgr,
2441 			   int pbn)
2442 {
2443 	int num_slots;
2444 
2445 	num_slots = DIV_ROUND_UP(pbn, mgr->pbn_div);
2446 
2447 	if (num_slots > mgr->avail_slots)
2448 		return -ENOSPC;
2449 	return num_slots;
2450 }
2451 EXPORT_SYMBOL(drm_dp_find_vcpi_slots);
2452 
drm_dp_init_vcpi(struct drm_dp_mst_topology_mgr * mgr,struct drm_dp_vcpi * vcpi,int pbn)2453 static int drm_dp_init_vcpi(struct drm_dp_mst_topology_mgr *mgr,
2454 			    struct drm_dp_vcpi *vcpi, int pbn)
2455 {
2456 	int num_slots;
2457 	int ret;
2458 
2459 	num_slots = DIV_ROUND_UP(pbn, mgr->pbn_div);
2460 
2461 	if (num_slots > mgr->avail_slots)
2462 		return -ENOSPC;
2463 
2464 	vcpi->pbn = pbn;
2465 	vcpi->aligned_pbn = num_slots * mgr->pbn_div;
2466 	vcpi->num_slots = num_slots;
2467 
2468 	ret = drm_dp_mst_assign_payload_id(mgr, vcpi);
2469 	if (ret < 0)
2470 		return ret;
2471 	return 0;
2472 }
2473 
2474 /**
2475  * drm_dp_mst_allocate_vcpi() - Allocate a virtual channel
2476  * @mgr: manager for this port
2477  * @port: port to allocate a virtual channel for.
2478  * @pbn: payload bandwidth number to request
2479  * @slots: returned number of slots for this PBN.
2480  */
drm_dp_mst_allocate_vcpi(struct drm_dp_mst_topology_mgr * mgr,struct drm_dp_mst_port * port,int pbn,int * slots)2481 bool drm_dp_mst_allocate_vcpi(struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port, int pbn, int *slots)
2482 {
2483 	int ret;
2484 
2485 	port = drm_dp_get_validated_port_ref(mgr, port);
2486 	if (!port)
2487 		return false;
2488 
2489 	if (port->vcpi.vcpi > 0) {
2490 		DRM_DEBUG_KMS("payload: vcpi %d already allocated for pbn %d - requested pbn %d\n", port->vcpi.vcpi, port->vcpi.pbn, pbn);
2491 		if (pbn == port->vcpi.pbn) {
2492 			*slots = port->vcpi.num_slots;
2493 			drm_dp_put_port(port);
2494 			return true;
2495 		}
2496 	}
2497 
2498 	ret = drm_dp_init_vcpi(mgr, &port->vcpi, pbn);
2499 	if (ret) {
2500 		DRM_DEBUG_KMS("failed to init vcpi %d %d %d\n", DIV_ROUND_UP(pbn, mgr->pbn_div), mgr->avail_slots, ret);
2501 		goto out;
2502 	}
2503 	DRM_DEBUG_KMS("initing vcpi for %d %d\n", pbn, port->vcpi.num_slots);
2504 	*slots = port->vcpi.num_slots;
2505 
2506 	drm_dp_put_port(port);
2507 	return true;
2508 out:
2509 	return false;
2510 }
2511 EXPORT_SYMBOL(drm_dp_mst_allocate_vcpi);
2512 
drm_dp_mst_get_vcpi_slots(struct drm_dp_mst_topology_mgr * mgr,struct drm_dp_mst_port * port)2513 int drm_dp_mst_get_vcpi_slots(struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port)
2514 {
2515 	int slots = 0;
2516 	port = drm_dp_get_validated_port_ref(mgr, port);
2517 	if (!port)
2518 		return slots;
2519 
2520 	slots = port->vcpi.num_slots;
2521 	drm_dp_put_port(port);
2522 	return slots;
2523 }
2524 EXPORT_SYMBOL(drm_dp_mst_get_vcpi_slots);
2525 
2526 /**
2527  * drm_dp_mst_reset_vcpi_slots() - Reset number of slots to 0 for VCPI
2528  * @mgr: manager for this port
2529  * @port: unverified pointer to a port.
2530  *
2531  * This just resets the number of slots for the ports VCPI for later programming.
2532  */
drm_dp_mst_reset_vcpi_slots(struct drm_dp_mst_topology_mgr * mgr,struct drm_dp_mst_port * port)2533 void drm_dp_mst_reset_vcpi_slots(struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port)
2534 {
2535 	port = drm_dp_get_validated_port_ref(mgr, port);
2536 	if (!port)
2537 		return;
2538 	port->vcpi.num_slots = 0;
2539 	drm_dp_put_port(port);
2540 }
2541 EXPORT_SYMBOL(drm_dp_mst_reset_vcpi_slots);
2542 
2543 /**
2544  * drm_dp_mst_deallocate_vcpi() - deallocate a VCPI
2545  * @mgr: manager for this port
2546  * @port: unverified port to deallocate vcpi for
2547  */
drm_dp_mst_deallocate_vcpi(struct drm_dp_mst_topology_mgr * mgr,struct drm_dp_mst_port * port)2548 void drm_dp_mst_deallocate_vcpi(struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port)
2549 {
2550 	port = drm_dp_get_validated_port_ref(mgr, port);
2551 	if (!port)
2552 		return;
2553 
2554 	drm_dp_mst_put_payload_id(mgr, port->vcpi.vcpi);
2555 	port->vcpi.num_slots = 0;
2556 	port->vcpi.pbn = 0;
2557 	port->vcpi.aligned_pbn = 0;
2558 	port->vcpi.vcpi = 0;
2559 	drm_dp_put_port(port);
2560 }
2561 EXPORT_SYMBOL(drm_dp_mst_deallocate_vcpi);
2562 
drm_dp_dpcd_write_payload(struct drm_dp_mst_topology_mgr * mgr,int id,struct drm_dp_payload * payload)2563 static int drm_dp_dpcd_write_payload(struct drm_dp_mst_topology_mgr *mgr,
2564 				     int id, struct drm_dp_payload *payload)
2565 {
2566 	u8 payload_alloc[3], status;
2567 	int ret;
2568 	int retries = 0;
2569 
2570 	drm_dp_dpcd_writeb(mgr->aux, DP_PAYLOAD_TABLE_UPDATE_STATUS,
2571 			   DP_PAYLOAD_TABLE_UPDATED);
2572 
2573 	payload_alloc[0] = id;
2574 	payload_alloc[1] = payload->start_slot;
2575 	payload_alloc[2] = payload->num_slots;
2576 
2577 	ret = drm_dp_dpcd_write(mgr->aux, DP_PAYLOAD_ALLOCATE_SET, payload_alloc, 3);
2578 	if (ret != 3) {
2579 		DRM_DEBUG_KMS("failed to write payload allocation %d\n", ret);
2580 		goto fail;
2581 	}
2582 
2583 retry:
2584 	ret = drm_dp_dpcd_readb(mgr->aux, DP_PAYLOAD_TABLE_UPDATE_STATUS, &status);
2585 	if (ret < 0) {
2586 		DRM_DEBUG_KMS("failed to read payload table status %d\n", ret);
2587 		goto fail;
2588 	}
2589 
2590 	if (!(status & DP_PAYLOAD_TABLE_UPDATED)) {
2591 		retries++;
2592 		if (retries < 20) {
2593 			usleep_range(10000, 20000);
2594 			goto retry;
2595 		}
2596 		DRM_DEBUG_KMS("status not set after read payload table status %d\n", status);
2597 		ret = -EINVAL;
2598 		goto fail;
2599 	}
2600 	ret = 0;
2601 fail:
2602 	return ret;
2603 }
2604 
2605 
2606 /**
2607  * drm_dp_check_act_status() - Check ACT handled status.
2608  * @mgr: manager to use
2609  *
2610  * Check the payload status bits in the DPCD for ACT handled completion.
2611  */
drm_dp_check_act_status(struct drm_dp_mst_topology_mgr * mgr)2612 int drm_dp_check_act_status(struct drm_dp_mst_topology_mgr *mgr)
2613 {
2614 	u8 status;
2615 	int ret;
2616 	int count = 0;
2617 
2618 	do {
2619 		ret = drm_dp_dpcd_readb(mgr->aux, DP_PAYLOAD_TABLE_UPDATE_STATUS, &status);
2620 
2621 		if (ret < 0) {
2622 			DRM_DEBUG_KMS("failed to read payload table status %d\n", ret);
2623 			goto fail;
2624 		}
2625 
2626 		if (status & DP_PAYLOAD_ACT_HANDLED)
2627 			break;
2628 		count++;
2629 		udelay(100);
2630 
2631 	} while (count < 30);
2632 
2633 	if (!(status & DP_PAYLOAD_ACT_HANDLED)) {
2634 		DRM_DEBUG_KMS("failed to get ACT bit %d after %d retries\n", status, count);
2635 		ret = -EINVAL;
2636 		goto fail;
2637 	}
2638 	return 0;
2639 fail:
2640 	return ret;
2641 }
2642 EXPORT_SYMBOL(drm_dp_check_act_status);
2643 
2644 /**
2645  * drm_dp_calc_pbn_mode() - Calculate the PBN for a mode.
2646  * @clock: dot clock for the mode
2647  * @bpp: bpp for the mode.
2648  *
2649  * This uses the formula in the spec to calculate the PBN value for a mode.
2650  */
drm_dp_calc_pbn_mode(int clock,int bpp)2651 int drm_dp_calc_pbn_mode(int clock, int bpp)
2652 {
2653 	u64 kbps;
2654 	s64 peak_kbps;
2655 	u32 numerator;
2656 	u32 denominator;
2657 
2658 	kbps = clock * bpp;
2659 
2660 	/*
2661 	 * margin 5300ppm + 300ppm ~ 0.6% as per spec, factor is 1.006
2662 	 * The unit of 54/64Mbytes/sec is an arbitrary unit chosen based on
2663 	 * common multiplier to render an integer PBN for all link rate/lane
2664 	 * counts combinations
2665 	 * calculate
2666 	 * peak_kbps *= (1006/1000)
2667 	 * peak_kbps *= (64/54)
2668 	 * peak_kbps *= 8    convert to bytes
2669 	 */
2670 
2671 	numerator = 64 * 1006;
2672 	denominator = 54 * 8 * 1000 * 1000;
2673 
2674 	kbps *= numerator;
2675 	peak_kbps = drm_fixp_from_fraction(kbps, denominator);
2676 
2677 	return drm_fixp2int_ceil(peak_kbps);
2678 }
2679 EXPORT_SYMBOL(drm_dp_calc_pbn_mode);
2680 
test_calc_pbn_mode(void)2681 static int test_calc_pbn_mode(void)
2682 {
2683 	int ret;
2684 	ret = drm_dp_calc_pbn_mode(154000, 30);
2685 	if (ret != 689) {
2686 		DRM_ERROR("PBN calculation test failed - clock %d, bpp %d, expected PBN %d, actual PBN %d.\n",
2687 				154000, 30, 689, ret);
2688 		return -EINVAL;
2689 	}
2690 	ret = drm_dp_calc_pbn_mode(234000, 30);
2691 	if (ret != 1047) {
2692 		DRM_ERROR("PBN calculation test failed - clock %d, bpp %d, expected PBN %d, actual PBN %d.\n",
2693 				234000, 30, 1047, ret);
2694 		return -EINVAL;
2695 	}
2696 	ret = drm_dp_calc_pbn_mode(297000, 24);
2697 	if (ret != 1063) {
2698 		DRM_ERROR("PBN calculation test failed - clock %d, bpp %d, expected PBN %d, actual PBN %d.\n",
2699 				297000, 24, 1063, ret);
2700 		return -EINVAL;
2701 	}
2702 	return 0;
2703 }
2704 
2705 /* we want to kick the TX after we've ack the up/down IRQs. */
drm_dp_mst_kick_tx(struct drm_dp_mst_topology_mgr * mgr)2706 static void drm_dp_mst_kick_tx(struct drm_dp_mst_topology_mgr *mgr)
2707 {
2708 	queue_work(system_long_wq, &mgr->tx_work);
2709 }
2710 
drm_dp_mst_dump_mstb(struct seq_file * m,struct drm_dp_mst_branch * mstb)2711 static void drm_dp_mst_dump_mstb(struct seq_file *m,
2712 				 struct drm_dp_mst_branch *mstb)
2713 {
2714 	struct drm_dp_mst_port *port;
2715 	int tabs = mstb->lct;
2716 	char prefix[10];
2717 	int i;
2718 
2719 	for (i = 0; i < tabs; i++)
2720 		prefix[i] = '\t';
2721 	prefix[i] = '\0';
2722 
2723 	seq_printf(m, "%smst: %p, %d\n", prefix, mstb, mstb->num_ports);
2724 	list_for_each_entry(port, &mstb->ports, next) {
2725 		seq_printf(m, "%sport: %d: ddps: %d ldps: %d, %p, conn: %p\n", prefix, port->port_num, port->ddps, port->ldps, port, port->connector);
2726 		if (port->mstb)
2727 			drm_dp_mst_dump_mstb(m, port->mstb);
2728 	}
2729 }
2730 
dump_dp_payload_table(struct drm_dp_mst_topology_mgr * mgr,char * buf)2731 static bool dump_dp_payload_table(struct drm_dp_mst_topology_mgr *mgr,
2732 				  char *buf)
2733 {
2734 	int ret;
2735 	int i;
2736 	for (i = 0; i < 4; i++) {
2737 		ret = drm_dp_dpcd_read(mgr->aux, DP_PAYLOAD_TABLE_UPDATE_STATUS + (i * 16), &buf[i * 16], 16);
2738 		if (ret != 16)
2739 			break;
2740 	}
2741 	if (i == 4)
2742 		return true;
2743 	return false;
2744 }
2745 
2746 /**
2747  * drm_dp_mst_dump_topology(): dump topology to seq file.
2748  * @m: seq_file to dump output to
2749  * @mgr: manager to dump current topology for.
2750  *
2751  * helper to dump MST topology to a seq file for debugfs.
2752  */
drm_dp_mst_dump_topology(struct seq_file * m,struct drm_dp_mst_topology_mgr * mgr)2753 void drm_dp_mst_dump_topology(struct seq_file *m,
2754 			      struct drm_dp_mst_topology_mgr *mgr)
2755 {
2756 	int i;
2757 	struct drm_dp_mst_port *port;
2758 	mutex_lock(&mgr->lock);
2759 	if (mgr->mst_primary)
2760 		drm_dp_mst_dump_mstb(m, mgr->mst_primary);
2761 
2762 	/* dump VCPIs */
2763 	mutex_unlock(&mgr->lock);
2764 
2765 	mutex_lock(&mgr->payload_lock);
2766 	seq_printf(m, "vcpi: %lx %lx\n", mgr->payload_mask, mgr->vcpi_mask);
2767 
2768 	for (i = 0; i < mgr->max_payloads; i++) {
2769 		if (mgr->proposed_vcpis[i]) {
2770 			port = container_of(mgr->proposed_vcpis[i], struct drm_dp_mst_port, vcpi);
2771 			seq_printf(m, "vcpi %d: %d %d %d\n", i, port->port_num, port->vcpi.vcpi, port->vcpi.num_slots);
2772 		} else
2773 			seq_printf(m, "vcpi %d:unsed\n", i);
2774 	}
2775 	for (i = 0; i < mgr->max_payloads; i++) {
2776 		seq_printf(m, "payload %d: %d, %d, %d\n",
2777 			   i,
2778 			   mgr->payloads[i].payload_state,
2779 			   mgr->payloads[i].start_slot,
2780 			   mgr->payloads[i].num_slots);
2781 
2782 
2783 	}
2784 	mutex_unlock(&mgr->payload_lock);
2785 
2786 	mutex_lock(&mgr->lock);
2787 	if (mgr->mst_primary) {
2788 		u8 buf[64];
2789 		bool bret;
2790 		int ret;
2791 		ret = drm_dp_dpcd_read(mgr->aux, DP_DPCD_REV, buf, DP_RECEIVER_CAP_SIZE);
2792 		seq_printf(m, "dpcd: ");
2793 		for (i = 0; i < DP_RECEIVER_CAP_SIZE; i++)
2794 			seq_printf(m, "%02x ", buf[i]);
2795 		seq_printf(m, "\n");
2796 		ret = drm_dp_dpcd_read(mgr->aux, DP_FAUX_CAP, buf, 2);
2797 		seq_printf(m, "faux/mst: ");
2798 		for (i = 0; i < 2; i++)
2799 			seq_printf(m, "%02x ", buf[i]);
2800 		seq_printf(m, "\n");
2801 		ret = drm_dp_dpcd_read(mgr->aux, DP_MSTM_CTRL, buf, 1);
2802 		seq_printf(m, "mst ctrl: ");
2803 		for (i = 0; i < 1; i++)
2804 			seq_printf(m, "%02x ", buf[i]);
2805 		seq_printf(m, "\n");
2806 
2807 		/* dump the standard OUI branch header */
2808 		ret = drm_dp_dpcd_read(mgr->aux, DP_BRANCH_OUI, buf, DP_BRANCH_OUI_HEADER_SIZE);
2809 		seq_printf(m, "branch oui: ");
2810 		for (i = 0; i < 0x3; i++)
2811 			seq_printf(m, "%02x", buf[i]);
2812 		seq_printf(m, " devid: ");
2813 		for (i = 0x3; i < 0x8; i++)
2814 			seq_printf(m, "%c", buf[i]);
2815 		seq_printf(m, " revision: hw: %x.%x sw: %x.%x", buf[0x9] >> 4, buf[0x9] & 0xf, buf[0xa], buf[0xb]);
2816 		seq_printf(m, "\n");
2817 		bret = dump_dp_payload_table(mgr, buf);
2818 		if (bret == true) {
2819 			seq_printf(m, "payload table: ");
2820 			for (i = 0; i < 63; i++)
2821 				seq_printf(m, "%02x ", buf[i]);
2822 			seq_printf(m, "\n");
2823 		}
2824 
2825 	}
2826 
2827 	mutex_unlock(&mgr->lock);
2828 
2829 }
2830 EXPORT_SYMBOL(drm_dp_mst_dump_topology);
2831 
drm_dp_tx_work(struct work_struct * work)2832 static void drm_dp_tx_work(struct work_struct *work)
2833 {
2834 	struct drm_dp_mst_topology_mgr *mgr = container_of(work, struct drm_dp_mst_topology_mgr, tx_work);
2835 
2836 	mutex_lock(&mgr->qlock);
2837 	if (mgr->tx_down_in_progress)
2838 		process_single_down_tx_qlock(mgr);
2839 	mutex_unlock(&mgr->qlock);
2840 }
2841 
drm_dp_free_mst_port(struct kref * kref)2842 static void drm_dp_free_mst_port(struct kref *kref)
2843 {
2844 	struct drm_dp_mst_port *port = container_of(kref, struct drm_dp_mst_port, kref);
2845 	kref_put(&port->parent->kref, drm_dp_free_mst_branch_device);
2846 	kfree(port);
2847 }
2848 
drm_dp_destroy_connector_work(struct work_struct * work)2849 static void drm_dp_destroy_connector_work(struct work_struct *work)
2850 {
2851 	struct drm_dp_mst_topology_mgr *mgr = container_of(work, struct drm_dp_mst_topology_mgr, destroy_connector_work);
2852 	struct drm_dp_mst_port *port;
2853 	bool send_hotplug = false;
2854 	/*
2855 	 * Not a regular list traverse as we have to drop the destroy
2856 	 * connector lock before destroying the connector, to avoid AB->BA
2857 	 * ordering between this lock and the config mutex.
2858 	 */
2859 	for (;;) {
2860 		mutex_lock(&mgr->destroy_connector_lock);
2861 		port = list_first_entry_or_null(&mgr->destroy_connector_list, struct drm_dp_mst_port, next);
2862 		if (!port) {
2863 			mutex_unlock(&mgr->destroy_connector_lock);
2864 			break;
2865 		}
2866 		list_del(&port->next);
2867 		mutex_unlock(&mgr->destroy_connector_lock);
2868 
2869 		kref_init(&port->kref);
2870 		INIT_LIST_HEAD(&port->next);
2871 
2872 		mgr->cbs->destroy_connector(mgr, port->connector);
2873 
2874 		drm_dp_port_teardown_pdt(port, port->pdt);
2875 
2876 		if (!port->input && port->vcpi.vcpi > 0) {
2877 			if (mgr->mst_state) {
2878 				drm_dp_mst_reset_vcpi_slots(mgr, port);
2879 				drm_dp_update_payload_part1(mgr);
2880 				drm_dp_mst_put_payload_id(mgr, port->vcpi.vcpi);
2881 			}
2882 		}
2883 
2884 		kref_put(&port->kref, drm_dp_free_mst_port);
2885 		send_hotplug = true;
2886 	}
2887 	if (send_hotplug)
2888 		(*mgr->cbs->hotplug)(mgr);
2889 }
2890 
2891 /**
2892  * drm_dp_mst_topology_mgr_init - initialise a topology manager
2893  * @mgr: manager struct to initialise
2894  * @dev: device providing this structure - for i2c addition.
2895  * @aux: DP helper aux channel to talk to this device
2896  * @max_dpcd_transaction_bytes: hw specific DPCD transaction limit
2897  * @max_payloads: maximum number of payloads this GPU can source
2898  * @conn_base_id: the connector object ID the MST device is connected to.
2899  *
2900  * Return 0 for success, or negative error code on failure
2901  */
drm_dp_mst_topology_mgr_init(struct drm_dp_mst_topology_mgr * mgr,struct device * dev,struct drm_dp_aux * aux,int max_dpcd_transaction_bytes,int max_payloads,int conn_base_id)2902 int drm_dp_mst_topology_mgr_init(struct drm_dp_mst_topology_mgr *mgr,
2903 				 struct device *dev, struct drm_dp_aux *aux,
2904 				 int max_dpcd_transaction_bytes,
2905 				 int max_payloads, int conn_base_id)
2906 {
2907 	mutex_init(&mgr->lock);
2908 	mutex_init(&mgr->qlock);
2909 	mutex_init(&mgr->payload_lock);
2910 	mutex_init(&mgr->destroy_connector_lock);
2911 	INIT_LIST_HEAD(&mgr->tx_msg_downq);
2912 	INIT_LIST_HEAD(&mgr->destroy_connector_list);
2913 	INIT_WORK(&mgr->work, drm_dp_mst_link_probe_work);
2914 	INIT_WORK(&mgr->tx_work, drm_dp_tx_work);
2915 	INIT_WORK(&mgr->destroy_connector_work, drm_dp_destroy_connector_work);
2916 	init_waitqueue_head(&mgr->tx_waitq);
2917 	mgr->dev = dev;
2918 	mgr->aux = aux;
2919 	mgr->max_dpcd_transaction_bytes = max_dpcd_transaction_bytes;
2920 	mgr->max_payloads = max_payloads;
2921 	mgr->conn_base_id = conn_base_id;
2922 	mgr->payloads = kcalloc(max_payloads, sizeof(struct drm_dp_payload), GFP_KERNEL);
2923 	if (!mgr->payloads)
2924 		return -ENOMEM;
2925 	mgr->proposed_vcpis = kcalloc(max_payloads, sizeof(struct drm_dp_vcpi *), GFP_KERNEL);
2926 	if (!mgr->proposed_vcpis)
2927 		return -ENOMEM;
2928 	set_bit(0, &mgr->payload_mask);
2929 	test_calc_pbn_mode();
2930 	return 0;
2931 }
2932 EXPORT_SYMBOL(drm_dp_mst_topology_mgr_init);
2933 
2934 /**
2935  * drm_dp_mst_topology_mgr_destroy() - destroy topology manager.
2936  * @mgr: manager to destroy
2937  */
drm_dp_mst_topology_mgr_destroy(struct drm_dp_mst_topology_mgr * mgr)2938 void drm_dp_mst_topology_mgr_destroy(struct drm_dp_mst_topology_mgr *mgr)
2939 {
2940 	flush_work(&mgr->work);
2941 	flush_work(&mgr->destroy_connector_work);
2942 	mutex_lock(&mgr->payload_lock);
2943 	kfree(mgr->payloads);
2944 	mgr->payloads = NULL;
2945 	kfree(mgr->proposed_vcpis);
2946 	mgr->proposed_vcpis = NULL;
2947 	mutex_unlock(&mgr->payload_lock);
2948 	mgr->dev = NULL;
2949 	mgr->aux = NULL;
2950 }
2951 EXPORT_SYMBOL(drm_dp_mst_topology_mgr_destroy);
2952 
2953 /* I2C device */
drm_dp_mst_i2c_xfer(struct i2c_adapter * adapter,struct i2c_msg * msgs,int num)2954 static int drm_dp_mst_i2c_xfer(struct i2c_adapter *adapter, struct i2c_msg *msgs,
2955 			       int num)
2956 {
2957 	struct drm_dp_aux *aux = adapter->algo_data;
2958 	struct drm_dp_mst_port *port = container_of(aux, struct drm_dp_mst_port, aux);
2959 	struct drm_dp_mst_branch *mstb;
2960 	struct drm_dp_mst_topology_mgr *mgr = port->mgr;
2961 	unsigned int i;
2962 	bool reading = false;
2963 	struct drm_dp_sideband_msg_req_body msg;
2964 	struct drm_dp_sideband_msg_tx *txmsg = NULL;
2965 	int ret;
2966 
2967 	mstb = drm_dp_get_validated_mstb_ref(mgr, port->parent);
2968 	if (!mstb)
2969 		return -EREMOTEIO;
2970 
2971 	/* construct i2c msg */
2972 	/* see if last msg is a read */
2973 	if (msgs[num - 1].flags & I2C_M_RD)
2974 		reading = true;
2975 
2976 	if (!reading || (num - 1 > DP_REMOTE_I2C_READ_MAX_TRANSACTIONS)) {
2977 		DRM_DEBUG_KMS("Unsupported I2C transaction for MST device\n");
2978 		ret = -EIO;
2979 		goto out;
2980 	}
2981 
2982 	memset(&msg, 0, sizeof(msg));
2983 	msg.req_type = DP_REMOTE_I2C_READ;
2984 	msg.u.i2c_read.num_transactions = num - 1;
2985 	msg.u.i2c_read.port_number = port->port_num;
2986 	for (i = 0; i < num - 1; i++) {
2987 		msg.u.i2c_read.transactions[i].i2c_dev_id = msgs[i].addr;
2988 		msg.u.i2c_read.transactions[i].num_bytes = msgs[i].len;
2989 		msg.u.i2c_read.transactions[i].bytes = msgs[i].buf;
2990 	}
2991 	msg.u.i2c_read.read_i2c_device_id = msgs[num - 1].addr;
2992 	msg.u.i2c_read.num_bytes_read = msgs[num - 1].len;
2993 
2994 	txmsg = kzalloc(sizeof(*txmsg), GFP_KERNEL);
2995 	if (!txmsg) {
2996 		ret = -ENOMEM;
2997 		goto out;
2998 	}
2999 
3000 	txmsg->dst = mstb;
3001 	drm_dp_encode_sideband_req(&msg, txmsg);
3002 
3003 	drm_dp_queue_down_tx(mgr, txmsg);
3004 
3005 	ret = drm_dp_mst_wait_tx_reply(mstb, txmsg);
3006 	if (ret > 0) {
3007 
3008 		if (txmsg->reply.reply_type == 1) { /* got a NAK back */
3009 			ret = -EREMOTEIO;
3010 			goto out;
3011 		}
3012 		if (txmsg->reply.u.remote_i2c_read_ack.num_bytes != msgs[num - 1].len) {
3013 			ret = -EIO;
3014 			goto out;
3015 		}
3016 		memcpy(msgs[num - 1].buf, txmsg->reply.u.remote_i2c_read_ack.bytes, msgs[num - 1].len);
3017 		ret = num;
3018 	}
3019 out:
3020 	kfree(txmsg);
3021 	drm_dp_put_mst_branch_device(mstb);
3022 	return ret;
3023 }
3024 
drm_dp_mst_i2c_functionality(struct i2c_adapter * adapter)3025 static u32 drm_dp_mst_i2c_functionality(struct i2c_adapter *adapter)
3026 {
3027 	return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL |
3028 	       I2C_FUNC_SMBUS_READ_BLOCK_DATA |
3029 	       I2C_FUNC_SMBUS_BLOCK_PROC_CALL |
3030 	       I2C_FUNC_10BIT_ADDR;
3031 }
3032 
3033 static const struct i2c_algorithm drm_dp_mst_i2c_algo = {
3034 	.functionality = drm_dp_mst_i2c_functionality,
3035 	.master_xfer = drm_dp_mst_i2c_xfer,
3036 };
3037 
3038 /**
3039  * drm_dp_mst_register_i2c_bus() - register an I2C adapter for I2C-over-AUX
3040  * @aux: DisplayPort AUX channel
3041  *
3042  * Returns 0 on success or a negative error code on failure.
3043  */
drm_dp_mst_register_i2c_bus(struct drm_dp_aux * aux)3044 static int drm_dp_mst_register_i2c_bus(struct drm_dp_aux *aux)
3045 {
3046 	aux->ddc.algo = &drm_dp_mst_i2c_algo;
3047 	aux->ddc.algo_data = aux;
3048 	aux->ddc.retries = 3;
3049 
3050 	aux->ddc.class = I2C_CLASS_DDC;
3051 	aux->ddc.owner = THIS_MODULE;
3052 	aux->ddc.dev.parent = aux->dev;
3053 	aux->ddc.dev.of_node = aux->dev->of_node;
3054 
3055 	strlcpy(aux->ddc.name, aux->name ? aux->name : dev_name(aux->dev),
3056 		sizeof(aux->ddc.name));
3057 
3058 	return i2c_add_adapter(&aux->ddc);
3059 }
3060 
3061 /**
3062  * drm_dp_mst_unregister_i2c_bus() - unregister an I2C-over-AUX adapter
3063  * @aux: DisplayPort AUX channel
3064  */
drm_dp_mst_unregister_i2c_bus(struct drm_dp_aux * aux)3065 static void drm_dp_mst_unregister_i2c_bus(struct drm_dp_aux *aux)
3066 {
3067 	i2c_del_adapter(&aux->ddc);
3068 }
3069