1 =========================
2 Kernel Mode Setting (KMS)
3 =========================
5 Drivers must initialize the mode setting core by calling
6 :c:func:`drm_mode_config_init()` on the DRM device. The function
7 initializes the :c:type:`struct drm_device <drm_device>`
8 mode_config field and never fails. Once done, mode configuration must
9 be setup by initializing the following fields.
11 - int min_width, min_height; int max_width, max_height;
12 Minimum and maximum width and height of the frame buffers in pixel
15 - struct drm_mode_config_funcs \*funcs;
16 Mode setting functions.
18 Modeset Base Object Abstraction
19 ===============================
21 .. kernel-doc:: include/drm/drm_mode_object.h
24 .. kernel-doc:: drivers/gpu/drm/drm_mode_object.c
30 .. kernel-doc:: include/drm/drm_crtc.h
36 .. kernel-doc:: drivers/gpu/drm/drm_crtc.c
39 Atomic Mode Setting Function Reference
40 ======================================
42 .. kernel-doc:: drivers/gpu/drm/drm_atomic.c
45 .. kernel-doc:: include/drm/drm_atomic.h
48 Frame Buffer Abstraction
49 ========================
51 .. kernel-doc:: drivers/gpu/drm/drm_framebuffer.c
54 Frame Buffer Functions Reference
55 --------------------------------
57 .. kernel-doc:: drivers/gpu/drm/drm_framebuffer.c
60 .. kernel-doc:: include/drm/drm_framebuffer.h
66 .. kernel-doc:: drivers/gpu/drm/drm_fourcc.c
72 The KMS API doesn't standardize backing storage object creation and
73 leaves it to driver-specific ioctls. Furthermore actually creating a
74 buffer object even for GEM-based drivers is done through a
75 driver-specific ioctl - GEM only has a common userspace interface for
76 sharing and destroying objects. While not an issue for full-fledged
77 graphics stacks that include device-specific userspace components (in
78 libdrm for instance), this limit makes DRM-based early boot graphics
79 unnecessarily complex.
81 Dumb objects partly alleviate the problem by providing a standard API to
82 create dumb buffers suitable for scanout, which can then be used to
83 create KMS frame buffers.
85 To support dumb objects drivers must implement the dumb_create,
86 dumb_destroy and dumb_map_offset operations.
88 - int (\*dumb_create)(struct drm_file \*file_priv, struct
89 drm_device \*dev, struct drm_mode_create_dumb \*args);
90 The dumb_create operation creates a driver object (GEM or TTM
91 handle) suitable for scanout based on the width, height and depth
92 from the struct :c:type:`struct drm_mode_create_dumb
93 <drm_mode_create_dumb>` argument. It fills the argument's
94 handle, pitch and size fields with a handle for the newly created
95 object and its line pitch and size in bytes.
97 - int (\*dumb_destroy)(struct drm_file \*file_priv, struct
98 drm_device \*dev, uint32_t handle);
99 The dumb_destroy operation destroys a dumb object created by
102 - int (\*dumb_map_offset)(struct drm_file \*file_priv, struct
103 drm_device \*dev, uint32_t handle, uint64_t \*offset);
104 The dumb_map_offset operation associates an mmap fake offset with
105 the object given by the handle and returns it. Drivers must use the
106 :c:func:`drm_gem_create_mmap_offset()` function to associate
107 the fake offset as described in ?.
109 Note that dumb objects may not be used for gpu acceleration, as has been
110 attempted on some ARM embedded platforms. Such drivers really must have
111 a hardware-specific ioctl to allocate suitable buffer objects.
113 Display Modes Function Reference
114 ================================
116 .. kernel-doc:: include/drm/drm_modes.h
119 .. kernel-doc:: drivers/gpu/drm/drm_modes.c
122 Connector Abstraction
123 =====================
125 .. kernel-doc:: drivers/gpu/drm/drm_connector.c
128 Connector Functions Reference
129 -----------------------------
131 .. kernel-doc:: include/drm/drm_connector.h
134 .. kernel-doc:: drivers/gpu/drm/drm_connector.c
140 .. kernel-doc:: drivers/gpu/drm/drm_encoder.c
143 Encoder Functions Reference
144 ---------------------------
146 .. kernel-doc:: include/drm/drm_encoder.h
149 .. kernel-doc:: drivers/gpu/drm/drm_encoder.c
152 KMS Initialization and Cleanup
153 ==============================
155 A KMS device is abstracted and exposed as a set of planes, CRTCs,
156 encoders and connectors. KMS drivers must thus create and initialize all
157 those objects at load time after initializing mode setting.
159 CRTCs (:c:type:`struct drm_crtc <drm_crtc>`)
160 --------------------------------------------
162 A CRTC is an abstraction representing a part of the chip that contains a
163 pointer to a scanout buffer. Therefore, the number of CRTCs available
164 determines how many independent scanout buffers can be active at any
165 given time. The CRTC structure contains several fields to support this:
166 a pointer to some video memory (abstracted as a frame buffer object), a
167 display mode, and an (x, y) offset into the video memory to support
168 panning or configurations where one piece of video memory spans multiple
174 A KMS device must create and register at least one struct
175 :c:type:`struct drm_crtc <drm_crtc>` instance. The instance is
176 allocated and zeroed by the driver, possibly as part of a larger
177 structure, and registered with a call to :c:func:`drm_crtc_init()`
178 with a pointer to CRTC functions.
180 Planes (:c:type:`struct drm_plane <drm_plane>`)
181 -----------------------------------------------
183 A plane represents an image source that can be blended with or overlayed
184 on top of a CRTC during the scanout process. Planes are associated with
185 a frame buffer to crop a portion of the image memory (source) and
186 optionally scale it to a destination size. The result is then blended
187 with or overlayed on top of a CRTC.
189 The DRM core recognizes three types of planes:
191 - DRM_PLANE_TYPE_PRIMARY represents a "main" plane for a CRTC.
192 Primary planes are the planes operated upon by CRTC modesetting and
193 flipping operations described in the page_flip hook in
194 :c:type:`struct drm_crtc_funcs <drm_crtc_funcs>`.
195 - DRM_PLANE_TYPE_CURSOR represents a "cursor" plane for a CRTC.
196 Cursor planes are the planes operated upon by the
197 DRM_IOCTL_MODE_CURSOR and DRM_IOCTL_MODE_CURSOR2 ioctls.
198 - DRM_PLANE_TYPE_OVERLAY represents all non-primary, non-cursor
199 planes. Some drivers refer to these types of planes as "sprites"
202 For compatibility with legacy userspace, only overlay planes are made
203 available to userspace by default. Userspace clients may set the
204 DRM_CLIENT_CAP_UNIVERSAL_PLANES client capability bit to indicate
205 that they wish to receive a universal plane list containing all plane
211 To create a plane, a KMS drivers allocates and zeroes an instances of
212 :c:type:`struct drm_plane <drm_plane>` (possibly as part of a
213 larger structure) and registers it with a call to
214 :c:func:`drm_universal_plane_init()`. The function takes a
215 bitmask of the CRTCs that can be associated with the plane, a pointer to
216 the plane functions, a list of format supported formats, and the type of
217 plane (primary, cursor, or overlay) being initialized.
219 Cursor and overlay planes are optional. All drivers should provide one
220 primary plane per CRTC (although this requirement may change in the
221 future); drivers that do not wish to provide special handling for
222 primary planes may make use of the helper functions described in ? to
223 create and register a primary plane with standard capabilities.
228 The DRM core manages its objects' lifetime. When an object is not needed
229 anymore the core calls its destroy function, which must clean up and
230 free every resource allocated for the object. Every
231 :c:func:`drm_\*_init()` call must be matched with a corresponding
232 :c:func:`drm_\*_cleanup()` call to cleanup CRTCs
233 (:c:func:`drm_crtc_cleanup()`), planes
234 (:c:func:`drm_plane_cleanup()`), encoders
235 (:c:func:`drm_encoder_cleanup()`) and connectors
236 (:c:func:`drm_connector_cleanup()`). Furthermore, connectors that
237 have been added to sysfs must be removed by a call to
238 :c:func:`drm_connector_unregister()` before calling
239 :c:func:`drm_connector_cleanup()`.
241 Connectors state change detection must be cleanup up with a call to
242 :c:func:`drm_kms_helper_poll_fini()`.
244 Output discovery and initialization example
245 -------------------------------------------
249 void intel_crt_init(struct drm_device *dev)
251 struct drm_connector *connector;
252 struct intel_output *intel_output;
254 intel_output = kzalloc(sizeof(struct intel_output), GFP_KERNEL);
258 connector = &intel_output->base;
259 drm_connector_init(dev, &intel_output->base,
260 &intel_crt_connector_funcs, DRM_MODE_CONNECTOR_VGA);
262 drm_encoder_init(dev, &intel_output->enc, &intel_crt_enc_funcs,
263 DRM_MODE_ENCODER_DAC);
265 drm_mode_connector_attach_encoder(&intel_output->base,
268 /* Set up the DDC bus. */
269 intel_output->ddc_bus = intel_i2c_create(dev, GPIOA, "CRTDDC_A");
270 if (!intel_output->ddc_bus) {
271 dev_printk(KERN_ERR, &dev->pdev->dev, "DDC bus registration "
276 intel_output->type = INTEL_OUTPUT_ANALOG;
277 connector->interlace_allowed = 0;
278 connector->doublescan_allowed = 0;
280 drm_encoder_helper_add(&intel_output->enc, &intel_crt_helper_funcs);
281 drm_connector_helper_add(connector, &intel_crt_connector_helper_funcs);
283 drm_connector_register(connector);
286 In the example above (taken from the i915 driver), a CRTC, connector and
287 encoder combination is created. A device-specific i2c bus is also
288 created for fetching EDID data and performing monitor detection. Once
289 the process is complete, the new connector is registered with sysfs to
290 make its properties available to applications.
295 .. kernel-doc:: drivers/gpu/drm/drm_modeset_lock.c
298 .. kernel-doc:: include/drm/drm_modeset_lock.h
301 .. kernel-doc:: drivers/gpu/drm/drm_modeset_lock.c
307 Drivers may need to expose additional parameters to applications than
308 those described in the previous sections. KMS supports attaching
309 properties to CRTCs, connectors and planes and offers a userspace API to
310 list, get and set the property values.
312 Properties are identified by a name that uniquely defines the property
313 purpose, and store an associated value. For all property types except
314 blob properties the value is a 64-bit unsigned integer.
316 KMS differentiates between properties and property instances. Drivers
317 first create properties and then create and associate individual
318 instances of those properties to objects. A property can be instantiated
319 multiple times and associated with different objects. Values are stored
320 in property instances, and all other property information are stored in
321 the property and shared between all instances of the property.
323 Every property is created with a type that influences how the KMS core
324 handles the property. Supported property types are
327 Range properties report their minimum and maximum admissible values.
328 The KMS core verifies that values set by application fit in that
332 Enumerated properties take a numerical value that ranges from 0 to
333 the number of enumerated values defined by the property minus one,
334 and associate a free-formed string name to each value. Applications
335 can retrieve the list of defined value-name pairs and use the
336 numerical value to get and set property instance values.
338 DRM_MODE_PROP_BITMASK
339 Bitmask properties are enumeration properties that additionally
340 restrict all enumerated values to the 0..63 range. Bitmask property
341 instance values combine one or more of the enumerated bits defined
345 Blob properties store a binary blob without any format restriction.
346 The binary blobs are created as KMS standalone objects, and blob
347 property instance values store the ID of their associated blob
350 Blob properties are only used for the connector EDID property and
351 cannot be created by drivers.
353 To create a property drivers call one of the following functions
354 depending on the property type. All property creation functions take
355 property flags and name, as well as type-specific arguments.
357 - struct drm_property \*drm_property_create_range(struct
358 drm_device \*dev, int flags, const char \*name, uint64_t min,
360 Create a range property with the given minimum and maximum values.
362 - struct drm_property \*drm_property_create_enum(struct drm_device
363 \*dev, int flags, const char \*name, const struct
364 drm_prop_enum_list \*props, int num_values);
365 Create an enumerated property. The ``props`` argument points to an
366 array of ``num_values`` value-name pairs.
368 - struct drm_property \*drm_property_create_bitmask(struct
369 drm_device \*dev, int flags, const char \*name, const struct
370 drm_prop_enum_list \*props, int num_values);
371 Create a bitmask property. The ``props`` argument points to an array
372 of ``num_values`` value-name pairs.
374 Properties can additionally be created as immutable, in which case they
375 will be read-only for applications but can be modified by the driver. To
376 create an immutable property drivers must set the
377 DRM_MODE_PROP_IMMUTABLE flag at property creation time.
379 When no array of value-name pairs is readily available at property
380 creation time for enumerated or range properties, drivers can create the
381 property using the :c:func:`drm_property_create()` function and
382 manually add enumeration value-name pairs by calling the
383 :c:func:`drm_property_add_enum()` function. Care must be taken to
384 properly specify the property type through the ``flags`` argument.
386 After creating properties drivers can attach property instances to CRTC,
387 connector and plane objects by calling the
388 :c:func:`drm_object_attach_property()`. The function takes a
389 pointer to the target object, a pointer to the previously created
390 property and an initial instance value.
392 Blending and Z-Position properties
393 ----------------------------------
395 .. kernel-doc:: drivers/gpu/drm/drm_blend.c
398 Existing KMS Properties
399 -----------------------
401 The following table gives description of drm properties exposed by
402 various modules/drivers.
406 :file: kms-properties.csv
411 Vertical blanking plays a major role in graphics rendering. To achieve
412 tear-free display, users must synchronize page flips and/or rendering to
413 vertical blanking. The DRM API offers ioctls to perform page flips
414 synchronized to vertical blanking and wait for vertical blanking.
416 The DRM core handles most of the vertical blanking management logic,
417 which involves filtering out spurious interrupts, keeping race-free
418 blanking counters, coping with counter wrap-around and resets and
419 keeping use counts. It relies on the driver to generate vertical
420 blanking interrupts and optionally provide a hardware vertical blanking
421 counter. Drivers must implement the following operations.
423 - int (\*enable_vblank) (struct drm_device \*dev, int crtc); void
424 (\*disable_vblank) (struct drm_device \*dev, int crtc);
425 Enable or disable vertical blanking interrupts for the given CRTC.
427 - u32 (\*get_vblank_counter) (struct drm_device \*dev, int crtc);
428 Retrieve the value of the vertical blanking counter for the given
429 CRTC. If the hardware maintains a vertical blanking counter its value
430 should be returned. Otherwise drivers can use the
431 :c:func:`drm_vblank_count()` helper function to handle this
434 Drivers must initialize the vertical blanking handling core with a call
435 to :c:func:`drm_vblank_init()` in their load operation.
437 Vertical blanking interrupts can be enabled by the DRM core or by
438 drivers themselves (for instance to handle page flipping operations).
439 The DRM core maintains a vertical blanking use count to ensure that the
440 interrupts are not disabled while a user still needs them. To increment
441 the use count, drivers call :c:func:`drm_vblank_get()`. Upon
442 return vertical blanking interrupts are guaranteed to be enabled.
444 To decrement the use count drivers call
445 :c:func:`drm_vblank_put()`. Only when the use count drops to zero
446 will the DRM core disable the vertical blanking interrupts after a delay
447 by scheduling a timer. The delay is accessible through the
448 vblankoffdelay module parameter or the ``drm_vblank_offdelay`` global
449 variable and expressed in milliseconds. Its default value is 5000 ms.
450 Zero means never disable, and a negative value means disable
451 immediately. Drivers may override the behaviour by setting the
452 :c:type:`struct drm_device <drm_device>`
453 vblank_disable_immediate flag, which when set causes vblank interrupts
454 to be disabled immediately regardless of the drm_vblank_offdelay
455 value. The flag should only be set if there's a properly working
456 hardware vblank counter present.
458 When a vertical blanking interrupt occurs drivers only need to call the
459 :c:func:`drm_handle_vblank()` function to account for the
462 Resources allocated by :c:func:`drm_vblank_init()` must be freed
463 with a call to :c:func:`drm_vblank_cleanup()` in the driver unload
466 Vertical Blanking and Interrupt Handling Functions Reference
467 ------------------------------------------------------------
469 .. kernel-doc:: drivers/gpu/drm/drm_irq.c
472 .. kernel-doc:: include/drm/drm_irq.h