1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * (C) COPYRIGHT 2018 ARM Limited. All rights reserved. 4 * Author: James.Qian.Wang <james.qian.wang@arm.com> 5 * 6 */ 7 #ifndef _KOMEDA_PIPELINE_H_ 8 #define _KOMEDA_PIPELINE_H_ 9 10 #include <linux/types.h> 11 #include <drm/drm_atomic.h> 12 #include <drm/drm_atomic_helper.h> 13 #include "malidp_utils.h" 14 15 #define KOMEDA_MAX_PIPELINES 2 16 #define KOMEDA_PIPELINE_MAX_LAYERS 4 17 #define KOMEDA_PIPELINE_MAX_SCALERS 2 18 #define KOMEDA_COMPONENT_N_INPUTS 5 19 20 /* pipeline component IDs */ 21 enum { 22 KOMEDA_COMPONENT_LAYER0 = 0, 23 KOMEDA_COMPONENT_LAYER1 = 1, 24 KOMEDA_COMPONENT_LAYER2 = 2, 25 KOMEDA_COMPONENT_LAYER3 = 3, 26 KOMEDA_COMPONENT_WB_LAYER = 7, /* write back layer */ 27 KOMEDA_COMPONENT_SCALER0 = 8, 28 KOMEDA_COMPONENT_SCALER1 = 9, 29 KOMEDA_COMPONENT_SPLITTER = 12, 30 KOMEDA_COMPONENT_MERGER = 14, 31 KOMEDA_COMPONENT_COMPIZ0 = 16, /* compositor */ 32 KOMEDA_COMPONENT_COMPIZ1 = 17, 33 KOMEDA_COMPONENT_IPS0 = 20, /* post image processor */ 34 KOMEDA_COMPONENT_IPS1 = 21, 35 KOMEDA_COMPONENT_TIMING_CTRLR = 22, /* timing controller */ 36 }; 37 38 #define KOMEDA_PIPELINE_LAYERS (BIT(KOMEDA_COMPONENT_LAYER0) |\ 39 BIT(KOMEDA_COMPONENT_LAYER1) |\ 40 BIT(KOMEDA_COMPONENT_LAYER2) |\ 41 BIT(KOMEDA_COMPONENT_LAYER3)) 42 43 #define KOMEDA_PIPELINE_SCALERS (BIT(KOMEDA_COMPONENT_SCALER0) |\ 44 BIT(KOMEDA_COMPONENT_SCALER1)) 45 46 #define KOMEDA_PIPELINE_COMPIZS (BIT(KOMEDA_COMPONENT_COMPIZ0) |\ 47 BIT(KOMEDA_COMPONENT_COMPIZ1)) 48 49 #define KOMEDA_PIPELINE_IMPROCS (BIT(KOMEDA_COMPONENT_IPS0) |\ 50 BIT(KOMEDA_COMPONENT_IPS1)) 51 struct komeda_component; 52 struct komeda_component_state; 53 54 /** komeda_component_funcs - component control functions */ 55 struct komeda_component_funcs { 56 /** @validate: optional, 57 * component may has special requirements or limitations, this function 58 * supply HW the ability to do the further HW specific check. 59 */ 60 int (*validate)(struct komeda_component *c, 61 struct komeda_component_state *state); 62 /** @update: update is a active update */ 63 void (*update)(struct komeda_component *c, 64 struct komeda_component_state *state); 65 /** @disable: disable component */ 66 void (*disable)(struct komeda_component *c); 67 /** @dump_register: Optional, dump registers to seq_file */ 68 void (*dump_register)(struct komeda_component *c, struct seq_file *seq); 69 }; 70 71 /** 72 * struct komeda_component 73 * 74 * struct komeda_component describe the data flow capabilities for how to link a 75 * component into the display pipeline. 76 * all specified components are subclass of this structure. 77 */ 78 struct komeda_component { 79 /** @obj: treat component as private obj */ 80 struct drm_private_obj obj; 81 /** @pipeline: the komeda pipeline this component belongs to */ 82 struct komeda_pipeline *pipeline; 83 /** @name: component name */ 84 char name[32]; 85 /** 86 * @reg: 87 * component register base, 88 * which is initialized by chip and used by chip only 89 */ 90 u32 __iomem *reg; 91 /** @id: component id */ 92 u32 id; 93 /** @hw_ic: component hw id, 94 * which is initialized by chip and used by chip only 95 */ 96 u32 hw_id; 97 98 /** 99 * @max_active_inputs: 100 * @max_active_outpus: 101 * 102 * maximum number of inputs/outputs that can be active in the same time 103 * Note: 104 * the number isn't the bit number of @supported_inputs or 105 * @supported_outputs, but may be less than it, since component may not 106 * support enabling all @supported_inputs/outputs at the same time. 107 */ 108 u8 max_active_inputs; 109 u8 max_active_outputs; 110 /** 111 * @supported_inputs: 112 * @supported_outputs: 113 * 114 * bitmask of BIT(component->id) for the supported inputs/outputs 115 * describes the possibilities of how a component is linked into a 116 * pipeline. 117 */ 118 u32 supported_inputs; 119 u32 supported_outputs; 120 121 /** 122 * @funcs: chip functions to access HW 123 */ 124 struct komeda_component_funcs *funcs; 125 }; 126 127 /** 128 * struct komeda_component_output 129 * 130 * a component has multiple outputs, if want to know where the data 131 * comes from, only know the component is not enough, we still need to know 132 * its output port 133 */ 134 struct komeda_component_output { 135 /** @component: indicate which component the data comes from */ 136 struct komeda_component *component; 137 /** @output_port: 138 * the output port of the &komeda_component_output.component 139 */ 140 u8 output_port; 141 }; 142 143 /** 144 * struct komeda_component_state 145 * 146 * component_state is the data flow configuration of the component, and it's 147 * the superclass of all specific component_state like @komeda_layer_state, 148 * @komeda_scaler_state 149 */ 150 struct komeda_component_state { 151 /** @obj: tracking component_state by drm_atomic_state */ 152 struct drm_private_state obj; 153 struct komeda_component *component; 154 /** 155 * @binding_user: 156 * currently bound user, the user can be crtc/plane/wb_conn, which is 157 * valid decided by @component and @inputs 158 * 159 * - Layer: its user always is plane. 160 * - compiz/improc/timing_ctrlr: the user is crtc. 161 * - wb_layer: wb_conn; 162 * - scaler: plane when input is layer, wb_conn if input is compiz. 163 */ 164 union { 165 struct drm_crtc *crtc; 166 struct drm_plane *plane; 167 struct drm_connector *wb_conn; 168 void *binding_user; 169 }; 170 /** 171 * @active_inputs: 172 * 173 * active_inputs is bitmask of @inputs index 174 * 175 * - active_inputs = changed_active_inputs + unchanged_active_inputs 176 * - affected_inputs = old->active_inputs + new->active_inputs; 177 * - disabling_inputs = affected_inputs ^ active_inputs; 178 * - changed_inputs = disabling_inputs + changed_active_inputs; 179 * 180 * NOTE: 181 * changed_inputs doesn't include all active_input but only 182 * @changed_active_inputs, and this bitmask can be used in chip 183 * level for dirty update. 184 */ 185 u16 active_inputs; 186 u16 changed_active_inputs; 187 u16 affected_inputs; 188 /** 189 * @inputs: 190 * 191 * the specific inputs[i] only valid on BIT(i) has been set in 192 * @active_inputs, if not the inputs[i] is undefined. 193 */ 194 struct komeda_component_output inputs[KOMEDA_COMPONENT_N_INPUTS]; 195 }; 196 197 static inline u16 component_disabling_inputs(struct komeda_component_state *st) 198 { 199 return st->affected_inputs ^ st->active_inputs; 200 } 201 202 static inline u16 component_changed_inputs(struct komeda_component_state *st) 203 { 204 return component_disabling_inputs(st) | st->changed_active_inputs; 205 } 206 207 #define to_comp(__c) (((__c) == NULL) ? NULL : &((__c)->base)) 208 #define to_cpos(__c) ((struct komeda_component **)&(__c)) 209 210 /* these structures are going to be filled in in uture patches */ 211 struct komeda_layer { 212 struct komeda_component base; 213 /* layer specific features and caps */ 214 int layer_type; /* RICH, SIMPLE or WB */ 215 }; 216 217 struct komeda_layer_state { 218 struct komeda_component_state base; 219 /* layer specific configuration state */ 220 }; 221 222 struct komeda_compiz { 223 struct komeda_component base; 224 /* compiz specific features and caps */ 225 }; 226 227 struct komeda_compiz_state { 228 struct komeda_component_state base; 229 /* compiz specific configuration state */ 230 }; 231 232 struct komeda_scaler { 233 struct komeda_component base; 234 /* scaler features and caps */ 235 }; 236 237 struct komeda_scaler_state { 238 struct komeda_component_state base; 239 }; 240 241 struct komeda_improc { 242 struct komeda_component base; 243 }; 244 245 struct komeda_improc_state { 246 struct komeda_component_state base; 247 }; 248 249 /* display timing controller */ 250 struct komeda_timing_ctrlr { 251 struct komeda_component base; 252 }; 253 254 struct komeda_timing_ctrlr_state { 255 struct komeda_component_state base; 256 }; 257 258 /** struct komeda_pipeline_funcs */ 259 struct komeda_pipeline_funcs { 260 /* dump_register: Optional, dump registers to seq_file */ 261 void (*dump_register)(struct komeda_pipeline *pipe, 262 struct seq_file *sf); 263 }; 264 265 /** 266 * struct komeda_pipeline 267 * 268 * Represent a complete display pipeline and hold all functional components. 269 */ 270 struct komeda_pipeline { 271 /** @obj: link pipeline as private obj of drm_atomic_state */ 272 struct drm_private_obj obj; 273 /** @mdev: the parent komeda_dev */ 274 struct komeda_dev *mdev; 275 /** @pxlclk: pixel clock */ 276 struct clk *pxlclk; 277 /** @aclk: AXI clock */ 278 struct clk *aclk; 279 /** @id: pipeline id */ 280 int id; 281 /** @avail_comps: available components mask of pipeline */ 282 u32 avail_comps; 283 int n_layers; 284 struct komeda_layer *layers[KOMEDA_PIPELINE_MAX_LAYERS]; 285 int n_scalers; 286 struct komeda_scaler *scalers[KOMEDA_PIPELINE_MAX_SCALERS]; 287 struct komeda_compiz *compiz; 288 struct komeda_layer *wb_layer; 289 struct komeda_improc *improc; 290 struct komeda_timing_ctrlr *ctrlr; 291 struct komeda_pipeline_funcs *funcs; /* private pipeline functions */ 292 293 /** @of_node: pipeline dt node */ 294 struct device_node *of_node; 295 /** @of_output_port: pipeline output port */ 296 struct device_node *of_output_port; 297 /** @of_output_dev: output connector device node */ 298 struct device_node *of_output_dev; 299 }; 300 301 /** 302 * struct komeda_pipeline_state 303 * 304 * NOTE: 305 * Unlike the pipeline, pipeline_state doesn’t gather any component_state 306 * into it. It because all component will be managed by drm_atomic_state. 307 */ 308 struct komeda_pipeline_state { 309 /** @obj: tracking pipeline_state by drm_atomic_state */ 310 struct drm_private_state obj; 311 struct komeda_pipeline *pipe; 312 /** @crtc: currently bound crtc */ 313 struct drm_crtc *crtc; 314 /** 315 * @active_comps: 316 * 317 * bitmask - BIT(component->id) of active components 318 */ 319 u32 active_comps; 320 }; 321 322 #define to_layer(c) container_of(c, struct komeda_layer, base) 323 #define to_compiz(c) container_of(c, struct komeda_compiz, base) 324 #define to_scaler(c) container_of(c, struct komeda_scaler, base) 325 #define to_improc(c) container_of(c, struct komeda_improc, base) 326 #define to_ctrlr(c) container_of(c, struct komeda_timing_ctrlr, base) 327 328 #define to_layer_st(c) container_of(c, struct komeda_layer_state, base) 329 #define to_compiz_st(c) container_of(c, struct komeda_compiz_state, base) 330 #define to_scaler_st(c) container_of(c, struct komeda_scaler_state, base) 331 #define to_improc_st(c) container_of(c, struct komeda_improc_state, base) 332 #define to_ctrlr_st(c) container_of(c, struct komeda_timing_ctrlr_state, base) 333 334 #define priv_to_comp_st(o) container_of(o, struct komeda_component_state, obj) 335 #define priv_to_pipe_st(o) container_of(o, struct komeda_pipeline_state, obj) 336 337 /* pipeline APIs */ 338 struct komeda_pipeline * 339 komeda_pipeline_add(struct komeda_dev *mdev, size_t size, 340 struct komeda_pipeline_funcs *funcs); 341 void komeda_pipeline_destroy(struct komeda_dev *mdev, 342 struct komeda_pipeline *pipe); 343 344 struct komeda_component * 345 komeda_pipeline_get_component(struct komeda_pipeline *pipe, int id); 346 347 /* component APIs */ 348 struct komeda_component * 349 komeda_component_add(struct komeda_pipeline *pipe, 350 size_t comp_sz, u32 id, u32 hw_id, 351 struct komeda_component_funcs *funcs, 352 u8 max_active_inputs, u32 supported_inputs, 353 u8 max_active_outputs, u32 __iomem *reg, 354 const char *name_fmt, ...); 355 356 void komeda_component_destroy(struct komeda_dev *mdev, 357 struct komeda_component *c); 358 359 #endif /* _KOMEDA_PIPELINE_H_*/ 360