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 #ifndef _DRM_DP_MST_HELPER_H_
23 #define _DRM_DP_MST_HELPER_H_
24
25 #include <linux/types.h>
26 #include <drm/drm_dp_helper.h>
27 #include <drm/drm_atomic.h>
28
29 struct drm_dp_mst_branch;
30
31 /**
32 * struct drm_dp_vcpi - Virtual Channel Payload Identifier
33 * @vcpi: Virtual channel ID.
34 * @pbn: Payload Bandwidth Number for this channel
35 * @aligned_pbn: PBN aligned with slot size
36 * @num_slots: number of slots for this PBN
37 */
38 struct drm_dp_vcpi {
39 int vcpi;
40 int pbn;
41 int aligned_pbn;
42 int num_slots;
43 };
44
45 /**
46 * struct drm_dp_mst_port - MST port
47 * @port_num: port number
48 * @input: if this port is an input port.
49 * @mcs: message capability status - DP 1.2 spec.
50 * @ddps: DisplayPort Device Plug Status - DP 1.2
51 * @pdt: Peer Device Type
52 * @ldps: Legacy Device Plug Status
53 * @dpcd_rev: DPCD revision of device on this port
54 * @num_sdp_streams: Number of simultaneous streams
55 * @num_sdp_stream_sinks: Number of stream sinks
56 * @available_pbn: Available bandwidth for this port.
57 * @next: link to next port on this branch device
58 * @mstb: branch device attach below this port
59 * @aux: i2c aux transport to talk to device connected to this port.
60 * @parent: branch device parent of this port
61 * @vcpi: Virtual Channel Payload info for this port.
62 * @connector: DRM connector this port is connected to.
63 * @mgr: topology manager this port lives under.
64 *
65 * This structure represents an MST port endpoint on a device somewhere
66 * in the MST topology.
67 */
68 struct drm_dp_mst_port {
69 /**
70 * @topology_kref: refcount for this port's lifetime in the topology,
71 * only the DP MST helpers should need to touch this
72 */
73 struct kref topology_kref;
74
75 /**
76 * @malloc_kref: refcount for the memory allocation containing this
77 * structure. See drm_dp_mst_get_port_malloc() and
78 * drm_dp_mst_put_port_malloc().
79 */
80 struct kref malloc_kref;
81
82 u8 port_num;
83 bool input;
84 bool mcs;
85 bool ddps;
86 u8 pdt;
87 bool ldps;
88 u8 dpcd_rev;
89 u8 num_sdp_streams;
90 u8 num_sdp_stream_sinks;
91 uint16_t available_pbn;
92 struct list_head next;
93 struct drm_dp_mst_branch *mstb; /* pointer to an mstb if this port has one */
94 struct drm_dp_aux aux; /* i2c bus for this port? */
95 struct drm_dp_mst_branch *parent;
96
97 struct drm_dp_vcpi vcpi;
98 struct drm_connector *connector;
99 struct drm_dp_mst_topology_mgr *mgr;
100
101 /**
102 * @cached_edid: for DP logical ports - make tiling work by ensuring
103 * that the EDID for all connectors is read immediately.
104 */
105 struct edid *cached_edid;
106 /**
107 * @has_audio: Tracks whether the sink connector to this port is
108 * audio-capable.
109 */
110 bool has_audio;
111 };
112
113 /**
114 * struct drm_dp_mst_branch - MST branch device.
115 * @rad: Relative Address to talk to this branch device.
116 * @lct: Link count total to talk to this branch device.
117 * @num_ports: number of ports on the branch.
118 * @msg_slots: one bit per transmitted msg slot.
119 * @ports: linked list of ports on this branch.
120 * @port_parent: pointer to the port parent, NULL if toplevel.
121 * @mgr: topology manager for this branch device.
122 * @tx_slots: transmission slots for this device.
123 * @last_seqno: last sequence number used to talk to this.
124 * @link_address_sent: if a link address message has been sent to this device yet.
125 * @guid: guid for DP 1.2 branch device. port under this branch can be
126 * identified by port #.
127 *
128 * This structure represents an MST branch device, there is one
129 * primary branch device at the root, along with any other branches connected
130 * to downstream port of parent branches.
131 */
132 struct drm_dp_mst_branch {
133 /**
134 * @topology_kref: refcount for this branch device's lifetime in the
135 * topology, only the DP MST helpers should need to touch this
136 */
137 struct kref topology_kref;
138
139 /**
140 * @malloc_kref: refcount for the memory allocation containing this
141 * structure. See drm_dp_mst_get_mstb_malloc() and
142 * drm_dp_mst_put_mstb_malloc().
143 */
144 struct kref malloc_kref;
145
146 u8 rad[8];
147 u8 lct;
148 int num_ports;
149
150 int msg_slots;
151 struct list_head ports;
152
153 /* list of tx ops queue for this port */
154 struct drm_dp_mst_port *port_parent;
155 struct drm_dp_mst_topology_mgr *mgr;
156
157 /* slots are protected by mstb->mgr->qlock */
158 struct drm_dp_sideband_msg_tx *tx_slots[2];
159 int last_seqno;
160 bool link_address_sent;
161
162 /* global unique identifier to identify branch devices */
163 u8 guid[16];
164 };
165
166
167 /* sideband msg header - not bit struct */
168 struct drm_dp_sideband_msg_hdr {
169 u8 lct;
170 u8 lcr;
171 u8 rad[8];
172 bool broadcast;
173 bool path_msg;
174 u8 msg_len;
175 bool somt;
176 bool eomt;
177 bool seqno;
178 };
179
180 struct drm_dp_nak_reply {
181 u8 guid[16];
182 u8 reason;
183 u8 nak_data;
184 };
185
186 struct drm_dp_link_address_ack_reply {
187 u8 guid[16];
188 u8 nports;
189 struct drm_dp_link_addr_reply_port {
190 bool input_port;
191 u8 peer_device_type;
192 u8 port_number;
193 bool mcs;
194 bool ddps;
195 bool legacy_device_plug_status;
196 u8 dpcd_revision;
197 u8 peer_guid[16];
198 u8 num_sdp_streams;
199 u8 num_sdp_stream_sinks;
200 } ports[16];
201 };
202
203 struct drm_dp_remote_dpcd_read_ack_reply {
204 u8 port_number;
205 u8 num_bytes;
206 u8 bytes[255];
207 };
208
209 struct drm_dp_remote_dpcd_write_ack_reply {
210 u8 port_number;
211 };
212
213 struct drm_dp_remote_dpcd_write_nak_reply {
214 u8 port_number;
215 u8 reason;
216 u8 bytes_written_before_failure;
217 };
218
219 struct drm_dp_remote_i2c_read_ack_reply {
220 u8 port_number;
221 u8 num_bytes;
222 u8 bytes[255];
223 };
224
225 struct drm_dp_remote_i2c_read_nak_reply {
226 u8 port_number;
227 u8 nak_reason;
228 u8 i2c_nak_transaction;
229 };
230
231 struct drm_dp_remote_i2c_write_ack_reply {
232 u8 port_number;
233 };
234
235
236 struct drm_dp_sideband_msg_rx {
237 u8 chunk[48];
238 u8 msg[256];
239 u8 curchunk_len;
240 u8 curchunk_idx; /* chunk we are parsing now */
241 u8 curchunk_hdrlen;
242 u8 curlen; /* total length of the msg */
243 bool have_somt;
244 bool have_eomt;
245 struct drm_dp_sideband_msg_hdr initial_hdr;
246 };
247
248 #define DRM_DP_MAX_SDP_STREAMS 16
249 struct drm_dp_allocate_payload {
250 u8 port_number;
251 u8 number_sdp_streams;
252 u8 vcpi;
253 u16 pbn;
254 u8 sdp_stream_sink[DRM_DP_MAX_SDP_STREAMS];
255 };
256
257 struct drm_dp_allocate_payload_ack_reply {
258 u8 port_number;
259 u8 vcpi;
260 u16 allocated_pbn;
261 };
262
263 struct drm_dp_connection_status_notify {
264 u8 guid[16];
265 u8 port_number;
266 bool legacy_device_plug_status;
267 bool displayport_device_plug_status;
268 bool message_capability_status;
269 bool input_port;
270 u8 peer_device_type;
271 };
272
273 struct drm_dp_remote_dpcd_read {
274 u8 port_number;
275 u32 dpcd_address;
276 u8 num_bytes;
277 };
278
279 struct drm_dp_remote_dpcd_write {
280 u8 port_number;
281 u32 dpcd_address;
282 u8 num_bytes;
283 u8 *bytes;
284 };
285
286 #define DP_REMOTE_I2C_READ_MAX_TRANSACTIONS 4
287 struct drm_dp_remote_i2c_read {
288 u8 num_transactions;
289 u8 port_number;
290 struct {
291 u8 i2c_dev_id;
292 u8 num_bytes;
293 u8 *bytes;
294 u8 no_stop_bit;
295 u8 i2c_transaction_delay;
296 } transactions[DP_REMOTE_I2C_READ_MAX_TRANSACTIONS];
297 u8 read_i2c_device_id;
298 u8 num_bytes_read;
299 };
300
301 struct drm_dp_remote_i2c_write {
302 u8 port_number;
303 u8 write_i2c_device_id;
304 u8 num_bytes;
305 u8 *bytes;
306 };
307
308 /* this covers ENUM_RESOURCES, POWER_DOWN_PHY, POWER_UP_PHY */
309 struct drm_dp_port_number_req {
310 u8 port_number;
311 };
312
313 struct drm_dp_enum_path_resources_ack_reply {
314 u8 port_number;
315 u16 full_payload_bw_number;
316 u16 avail_payload_bw_number;
317 };
318
319 /* covers POWER_DOWN_PHY, POWER_UP_PHY */
320 struct drm_dp_port_number_rep {
321 u8 port_number;
322 };
323
324 struct drm_dp_query_payload {
325 u8 port_number;
326 u8 vcpi;
327 };
328
329 struct drm_dp_resource_status_notify {
330 u8 port_number;
331 u8 guid[16];
332 u16 available_pbn;
333 };
334
335 struct drm_dp_query_payload_ack_reply {
336 u8 port_number;
337 u16 allocated_pbn;
338 };
339
340 struct drm_dp_sideband_msg_req_body {
341 u8 req_type;
342 union ack_req {
343 struct drm_dp_connection_status_notify conn_stat;
344 struct drm_dp_port_number_req port_num;
345 struct drm_dp_resource_status_notify resource_stat;
346
347 struct drm_dp_query_payload query_payload;
348 struct drm_dp_allocate_payload allocate_payload;
349
350 struct drm_dp_remote_dpcd_read dpcd_read;
351 struct drm_dp_remote_dpcd_write dpcd_write;
352
353 struct drm_dp_remote_i2c_read i2c_read;
354 struct drm_dp_remote_i2c_write i2c_write;
355 } u;
356 };
357
358 struct drm_dp_sideband_msg_reply_body {
359 u8 reply_type;
360 u8 req_type;
361 union ack_replies {
362 struct drm_dp_nak_reply nak;
363 struct drm_dp_link_address_ack_reply link_addr;
364 struct drm_dp_port_number_rep port_number;
365
366 struct drm_dp_enum_path_resources_ack_reply path_resources;
367 struct drm_dp_allocate_payload_ack_reply allocate_payload;
368 struct drm_dp_query_payload_ack_reply query_payload;
369
370 struct drm_dp_remote_dpcd_read_ack_reply remote_dpcd_read_ack;
371 struct drm_dp_remote_dpcd_write_ack_reply remote_dpcd_write_ack;
372 struct drm_dp_remote_dpcd_write_nak_reply remote_dpcd_write_nack;
373
374 struct drm_dp_remote_i2c_read_ack_reply remote_i2c_read_ack;
375 struct drm_dp_remote_i2c_read_nak_reply remote_i2c_read_nack;
376 struct drm_dp_remote_i2c_write_ack_reply remote_i2c_write_ack;
377 } u;
378 };
379
380 /* msg is queued to be put into a slot */
381 #define DRM_DP_SIDEBAND_TX_QUEUED 0
382 /* msg has started transmitting on a slot - still on msgq */
383 #define DRM_DP_SIDEBAND_TX_START_SEND 1
384 /* msg has finished transmitting on a slot - removed from msgq only in slot */
385 #define DRM_DP_SIDEBAND_TX_SENT 2
386 /* msg has received a response - removed from slot */
387 #define DRM_DP_SIDEBAND_TX_RX 3
388 #define DRM_DP_SIDEBAND_TX_TIMEOUT 4
389
390 struct drm_dp_sideband_msg_tx {
391 u8 msg[256];
392 u8 chunk[48];
393 u8 cur_offset;
394 u8 cur_len;
395 struct drm_dp_mst_branch *dst;
396 struct list_head next;
397 int seqno;
398 int state;
399 bool path_msg;
400 struct drm_dp_sideband_msg_reply_body reply;
401 };
402
403 /* sideband msg handler */
404 struct drm_dp_mst_topology_mgr;
405 struct drm_dp_mst_topology_cbs {
406 /* create a connector for a port */
407 struct drm_connector *(*add_connector)(struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port, const char *path);
408 void (*register_connector)(struct drm_connector *connector);
409 void (*destroy_connector)(struct drm_dp_mst_topology_mgr *mgr,
410 struct drm_connector *connector);
411 };
412
413 #define DP_MAX_PAYLOAD (sizeof(unsigned long) * 8)
414
415 #define DP_PAYLOAD_LOCAL 1
416 #define DP_PAYLOAD_REMOTE 2
417 #define DP_PAYLOAD_DELETE_LOCAL 3
418
419 struct drm_dp_payload {
420 int payload_state;
421 int start_slot;
422 int num_slots;
423 int vcpi;
424 };
425
426 #define to_dp_mst_topology_state(x) container_of(x, struct drm_dp_mst_topology_state, base)
427
428 struct drm_dp_vcpi_allocation {
429 struct drm_dp_mst_port *port;
430 int vcpi;
431 struct list_head next;
432 };
433
434 struct drm_dp_mst_topology_state {
435 struct drm_private_state base;
436 struct list_head vcpis;
437 struct drm_dp_mst_topology_mgr *mgr;
438 };
439
440 #define to_dp_mst_topology_mgr(x) container_of(x, struct drm_dp_mst_topology_mgr, base)
441
442 /**
443 * struct drm_dp_mst_topology_mgr - DisplayPort MST manager
444 *
445 * This struct represents the toplevel displayport MST topology manager.
446 * There should be one instance of this for every MST capable DP connector
447 * on the GPU.
448 */
449 struct drm_dp_mst_topology_mgr {
450 /**
451 * @base: Base private object for atomic
452 */
453 struct drm_private_obj base;
454
455 /**
456 * @dev: device pointer for adding i2c devices etc.
457 */
458 struct drm_device *dev;
459 /**
460 * @cbs: callbacks for connector addition and destruction.
461 */
462 const struct drm_dp_mst_topology_cbs *cbs;
463 /**
464 * @max_dpcd_transaction_bytes: maximum number of bytes to read/write
465 * in one go.
466 */
467 int max_dpcd_transaction_bytes;
468 /**
469 * @aux: AUX channel for the DP MST connector this topolgy mgr is
470 * controlling.
471 */
472 struct drm_dp_aux *aux;
473 /**
474 * @max_payloads: maximum number of payloads the GPU can generate.
475 */
476 int max_payloads;
477 /**
478 * @conn_base_id: DRM connector ID this mgr is connected to. Only used
479 * to build the MST connector path value.
480 */
481 int conn_base_id;
482
483 /**
484 * @down_rep_recv: Message receiver state for down replies. This and
485 * @up_req_recv are only ever access from the work item, which is
486 * serialised.
487 */
488 struct drm_dp_sideband_msg_rx down_rep_recv;
489 /**
490 * @up_req_recv: Message receiver state for up requests. This and
491 * @down_rep_recv are only ever access from the work item, which is
492 * serialised.
493 */
494 struct drm_dp_sideband_msg_rx up_req_recv;
495
496 /**
497 * @lock: protects mst state, primary, dpcd.
498 */
499 struct mutex lock;
500
501 /**
502 * @mst_state: If this manager is enabled for an MST capable port. False
503 * if no MST sink/branch devices is connected.
504 */
505 bool mst_state;
506 /**
507 * @mst_primary: Pointer to the primary/first branch device.
508 */
509 struct drm_dp_mst_branch *mst_primary;
510
511 /**
512 * @dpcd: Cache of DPCD for primary port.
513 */
514 u8 dpcd[DP_RECEIVER_CAP_SIZE];
515 /**
516 * @sink_count: Sink count from DEVICE_SERVICE_IRQ_VECTOR_ESI0.
517 */
518 u8 sink_count;
519 /**
520 * @pbn_div: PBN to slots divisor.
521 */
522 int pbn_div;
523
524 /**
525 * @funcs: Atomic helper callbacks
526 */
527 const struct drm_private_state_funcs *funcs;
528
529 /**
530 * @qlock: protects @tx_msg_downq, the &drm_dp_mst_branch.txslost and
531 * &drm_dp_sideband_msg_tx.state once they are queued
532 */
533 struct mutex qlock;
534 /**
535 * @tx_msg_downq: List of pending down replies.
536 */
537 struct list_head tx_msg_downq;
538
539 /**
540 * @payload_lock: Protect payload information.
541 */
542 struct mutex payload_lock;
543 /**
544 * @proposed_vcpis: Array of pointers for the new VCPI allocation. The
545 * VCPI structure itself is &drm_dp_mst_port.vcpi.
546 */
547 struct drm_dp_vcpi **proposed_vcpis;
548 /**
549 * @payloads: Array of payloads.
550 */
551 struct drm_dp_payload *payloads;
552 /**
553 * @payload_mask: Elements of @payloads actually in use. Since
554 * reallocation of active outputs isn't possible gaps can be created by
555 * disabling outputs out of order compared to how they've been enabled.
556 */
557 unsigned long payload_mask;
558 /**
559 * @vcpi_mask: Similar to @payload_mask, but for @proposed_vcpis.
560 */
561 unsigned long vcpi_mask;
562
563 /**
564 * @tx_waitq: Wait to queue stall for the tx worker.
565 */
566 wait_queue_head_t tx_waitq;
567 /**
568 * @work: Probe work.
569 */
570 struct work_struct work;
571 /**
572 * @tx_work: Sideband transmit worker. This can nest within the main
573 * @work worker for each transaction @work launches.
574 */
575 struct work_struct tx_work;
576
577 /**
578 * @destroy_connector_list: List of to be destroyed connectors.
579 */
580 struct list_head destroy_connector_list;
581 /**
582 * @destroy_connector_lock: Protects @connector_list.
583 */
584 struct mutex destroy_connector_lock;
585 /**
586 * @destroy_connector_work: Work item to destroy connectors. Needed to
587 * avoid locking inversion.
588 */
589 struct work_struct destroy_connector_work;
590 };
591
592 int drm_dp_mst_topology_mgr_init(struct drm_dp_mst_topology_mgr *mgr,
593 struct drm_device *dev, struct drm_dp_aux *aux,
594 int max_dpcd_transaction_bytes,
595 int max_payloads, int conn_base_id);
596
597 void drm_dp_mst_topology_mgr_destroy(struct drm_dp_mst_topology_mgr *mgr);
598
599
600 int drm_dp_mst_topology_mgr_set_mst(struct drm_dp_mst_topology_mgr *mgr, bool mst_state);
601
602
603 int drm_dp_mst_hpd_irq(struct drm_dp_mst_topology_mgr *mgr, u8 *esi, bool *handled);
604
605
606 enum drm_connector_status drm_dp_mst_detect_port(struct drm_connector *connector, struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port);
607
608 bool drm_dp_mst_port_has_audio(struct drm_dp_mst_topology_mgr *mgr,
609 struct drm_dp_mst_port *port);
610 struct edid *drm_dp_mst_get_edid(struct drm_connector *connector, struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port);
611
612
613 int drm_dp_calc_pbn_mode(int clock, int bpp);
614
615
616 bool drm_dp_mst_allocate_vcpi(struct drm_dp_mst_topology_mgr *mgr,
617 struct drm_dp_mst_port *port, int pbn, int slots);
618
619 int drm_dp_mst_get_vcpi_slots(struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port);
620
621
622 void drm_dp_mst_reset_vcpi_slots(struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port);
623
624
625 void drm_dp_mst_deallocate_vcpi(struct drm_dp_mst_topology_mgr *mgr,
626 struct drm_dp_mst_port *port);
627
628
629 int drm_dp_find_vcpi_slots(struct drm_dp_mst_topology_mgr *mgr,
630 int pbn);
631
632
633 int drm_dp_update_payload_part1(struct drm_dp_mst_topology_mgr *mgr);
634
635
636 int drm_dp_update_payload_part2(struct drm_dp_mst_topology_mgr *mgr);
637
638 int drm_dp_check_act_status(struct drm_dp_mst_topology_mgr *mgr);
639
640 void drm_dp_mst_dump_topology(struct seq_file *m,
641 struct drm_dp_mst_topology_mgr *mgr);
642
643 void drm_dp_mst_topology_mgr_suspend(struct drm_dp_mst_topology_mgr *mgr);
644 int __must_check
645 drm_dp_mst_topology_mgr_resume(struct drm_dp_mst_topology_mgr *mgr);
646
647 ssize_t drm_dp_mst_dpcd_read(struct drm_dp_aux *aux,
648 unsigned int offset, void *buffer, size_t size);
649 ssize_t drm_dp_mst_dpcd_write(struct drm_dp_aux *aux,
650 unsigned int offset, void *buffer, size_t size);
651
652 int drm_dp_mst_connector_late_register(struct drm_connector *connector,
653 struct drm_dp_mst_port *port);
654 void drm_dp_mst_connector_early_unregister(struct drm_connector *connector,
655 struct drm_dp_mst_port *port);
656
657 struct drm_dp_mst_topology_state *drm_atomic_get_mst_topology_state(struct drm_atomic_state *state,
658 struct drm_dp_mst_topology_mgr *mgr);
659 int __must_check
660 drm_dp_atomic_find_vcpi_slots(struct drm_atomic_state *state,
661 struct drm_dp_mst_topology_mgr *mgr,
662 struct drm_dp_mst_port *port, int pbn);
663 int __must_check
664 drm_dp_atomic_release_vcpi_slots(struct drm_atomic_state *state,
665 struct drm_dp_mst_topology_mgr *mgr,
666 struct drm_dp_mst_port *port);
667 int drm_dp_send_power_updown_phy(struct drm_dp_mst_topology_mgr *mgr,
668 struct drm_dp_mst_port *port, bool power_up);
669 int __must_check drm_dp_mst_atomic_check(struct drm_atomic_state *state);
670
671 void drm_dp_mst_get_port_malloc(struct drm_dp_mst_port *port);
672 void drm_dp_mst_put_port_malloc(struct drm_dp_mst_port *port);
673
674 extern const struct drm_private_state_funcs drm_dp_mst_topology_state_funcs;
675
676 /**
677 * __drm_dp_mst_state_iter_get - private atomic state iterator function for
678 * macro-internal use
679 * @state: &struct drm_atomic_state pointer
680 * @mgr: pointer to the &struct drm_dp_mst_topology_mgr iteration cursor
681 * @old_state: optional pointer to the old &struct drm_dp_mst_topology_state
682 * iteration cursor
683 * @new_state: optional pointer to the new &struct drm_dp_mst_topology_state
684 * iteration cursor
685 * @i: int iteration cursor, for macro-internal use
686 *
687 * Used by for_each_oldnew_mst_mgr_in_state(),
688 * for_each_old_mst_mgr_in_state(), and for_each_new_mst_mgr_in_state(). Don't
689 * call this directly.
690 *
691 * Returns:
692 * True if the current &struct drm_private_obj is a &struct
693 * drm_dp_mst_topology_mgr, false otherwise.
694 */
695 static inline bool
696 __drm_dp_mst_state_iter_get(struct drm_atomic_state *state,
697 struct drm_dp_mst_topology_mgr **mgr,
698 struct drm_dp_mst_topology_state **old_state,
699 struct drm_dp_mst_topology_state **new_state,
700 int i)
701 {
702 struct __drm_private_objs_state *objs_state = &state->private_objs[i];
703
704 if (objs_state->ptr->funcs != &drm_dp_mst_topology_state_funcs)
705 return false;
706
707 *mgr = to_dp_mst_topology_mgr(objs_state->ptr);
708 if (old_state)
709 *old_state = to_dp_mst_topology_state(objs_state->old_state);
710 if (new_state)
711 *new_state = to_dp_mst_topology_state(objs_state->new_state);
712
713 return true;
714 }
715
716 /**
717 * for_each_oldnew_mst_mgr_in_state - iterate over all DP MST topology
718 * managers in an atomic update
719 * @__state: &struct drm_atomic_state pointer
720 * @mgr: &struct drm_dp_mst_topology_mgr iteration cursor
721 * @old_state: &struct drm_dp_mst_topology_state iteration cursor for the old
722 * state
723 * @new_state: &struct drm_dp_mst_topology_state iteration cursor for the new
724 * state
725 * @__i: int iteration cursor, for macro-internal use
726 *
727 * This iterates over all DRM DP MST topology managers in an atomic update,
728 * tracking both old and new state. This is useful in places where the state
729 * delta needs to be considered, for example in atomic check functions.
730 */
731 #define for_each_oldnew_mst_mgr_in_state(__state, mgr, old_state, new_state, __i) \
732 for ((__i) = 0; (__i) < (__state)->num_private_objs; (__i)++) \
733 for_each_if(__drm_dp_mst_state_iter_get((__state), &(mgr), &(old_state), &(new_state), (__i)))
734
735 /**
736 * for_each_old_mst_mgr_in_state - iterate over all DP MST topology managers
737 * in an atomic update
738 * @__state: &struct drm_atomic_state pointer
739 * @mgr: &struct drm_dp_mst_topology_mgr iteration cursor
740 * @old_state: &struct drm_dp_mst_topology_state iteration cursor for the old
741 * state
742 * @__i: int iteration cursor, for macro-internal use
743 *
744 * This iterates over all DRM DP MST topology managers in an atomic update,
745 * tracking only the old state. This is useful in disable functions, where we
746 * need the old state the hardware is still in.
747 */
748 #define for_each_old_mst_mgr_in_state(__state, mgr, old_state, __i) \
749 for ((__i) = 0; (__i) < (__state)->num_private_objs; (__i)++) \
750 for_each_if(__drm_dp_mst_state_iter_get((__state), &(mgr), &(old_state), NULL, (__i)))
751
752 /**
753 * for_each_new_mst_mgr_in_state - iterate over all DP MST topology managers
754 * in an atomic update
755 * @__state: &struct drm_atomic_state pointer
756 * @mgr: &struct drm_dp_mst_topology_mgr iteration cursor
757 * @new_state: &struct drm_dp_mst_topology_state iteration cursor for the new
758 * state
759 * @__i: int iteration cursor, for macro-internal use
760 *
761 * This iterates over all DRM DP MST topology managers in an atomic update,
762 * tracking only the new state. This is useful in enable functions, where we
763 * need the new state the hardware should be in when the atomic commit
764 * operation has completed.
765 */
766 #define for_each_new_mst_mgr_in_state(__state, mgr, new_state, __i) \
767 for ((__i) = 0; (__i) < (__state)->num_private_objs; (__i)++) \
768 for_each_if(__drm_dp_mst_state_iter_get((__state), &(mgr), NULL, &(new_state), (__i)))
769
770 #endif