1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright 2018 Noralf Trønnes
6 #include <linux/list.h>
7 #include <linux/module.h>
8 #include <linux/mutex.h>
9 #include <linux/seq_file.h>
10 #include <linux/slab.h>
12 #include <drm/drm_client.h>
13 #include <drm/drm_debugfs.h>
14 #include <drm/drm_device.h>
15 #include <drm/drm_drv.h>
16 #include <drm/drm_file.h>
17 #include <drm/drm_fourcc.h>
18 #include <drm/drm_framebuffer.h>
19 #include <drm/drm_gem.h>
20 #include <drm/drm_mode.h>
21 #include <drm/drm_print.h>
23 #include "drm_crtc_internal.h"
24 #include "drm_internal.h"
29 * This library provides support for clients running in the kernel like fbdev and bootsplash.
31 * GEM drivers which provide a GEM based dumb buffer with a virtual address are supported.
34 static int drm_client_open(struct drm_client_dev
*client
)
36 struct drm_device
*dev
= client
->dev
;
37 struct drm_file
*file
;
39 file
= drm_file_alloc(dev
->primary
);
43 mutex_lock(&dev
->filelist_mutex
);
44 list_add(&file
->lhead
, &dev
->filelist_internal
);
45 mutex_unlock(&dev
->filelist_mutex
);
52 static void drm_client_close(struct drm_client_dev
*client
)
54 struct drm_device
*dev
= client
->dev
;
56 mutex_lock(&dev
->filelist_mutex
);
57 list_del(&client
->file
->lhead
);
58 mutex_unlock(&dev
->filelist_mutex
);
60 drm_file_free(client
->file
);
62 EXPORT_SYMBOL(drm_client_close
);
65 * drm_client_init - Initialise a DRM client
69 * @funcs: DRM client functions (optional)
71 * This initialises the client and opens a &drm_file.
72 * Use drm_client_register() to complete the process.
73 * The caller needs to hold a reference on @dev before calling this function.
74 * The client is freed when the &drm_device is unregistered. See drm_client_release().
77 * Zero on success or negative error code on failure.
79 int drm_client_init(struct drm_device
*dev
, struct drm_client_dev
*client
,
80 const char *name
, const struct drm_client_funcs
*funcs
)
84 if (!drm_core_check_feature(dev
, DRIVER_MODESET
) || !dev
->driver
->dumb_create
)
87 if (funcs
&& !try_module_get(funcs
->owner
))
92 client
->funcs
= funcs
;
94 ret
= drm_client_modeset_create(client
);
98 ret
= drm_client_open(client
);
107 drm_client_modeset_free(client
);
110 module_put(funcs
->owner
);
114 EXPORT_SYMBOL(drm_client_init
);
117 * drm_client_register - Register client
118 * @client: DRM client
120 * Add the client to the &drm_device client list to activate its callbacks.
121 * @client must be initialized by a call to drm_client_init(). After
122 * drm_client_register() it is no longer permissible to call drm_client_release()
123 * directly (outside the unregister callback), instead cleanup will happen
124 * automatically on driver unload.
126 void drm_client_register(struct drm_client_dev
*client
)
128 struct drm_device
*dev
= client
->dev
;
130 mutex_lock(&dev
->clientlist_mutex
);
131 list_add(&client
->list
, &dev
->clientlist
);
132 mutex_unlock(&dev
->clientlist_mutex
);
134 EXPORT_SYMBOL(drm_client_register
);
137 * drm_client_release - Release DRM client resources
138 * @client: DRM client
140 * Releases resources by closing the &drm_file that was opened by drm_client_init().
141 * It is called automatically if the &drm_client_funcs.unregister callback is _not_ set.
143 * This function should only be called from the unregister callback. An exception
144 * is fbdev which cannot free the buffer if userspace has open file descriptors.
147 * Clients cannot initiate a release by themselves. This is done to keep the code simple.
148 * The driver has to be unloaded before the client can be unloaded.
150 void drm_client_release(struct drm_client_dev
*client
)
152 struct drm_device
*dev
= client
->dev
;
154 DRM_DEV_DEBUG_KMS(dev
->dev
, "%s\n", client
->name
);
156 drm_client_modeset_free(client
);
157 drm_client_close(client
);
160 module_put(client
->funcs
->owner
);
162 EXPORT_SYMBOL(drm_client_release
);
164 void drm_client_dev_unregister(struct drm_device
*dev
)
166 struct drm_client_dev
*client
, *tmp
;
168 if (!drm_core_check_feature(dev
, DRIVER_MODESET
))
171 mutex_lock(&dev
->clientlist_mutex
);
172 list_for_each_entry_safe(client
, tmp
, &dev
->clientlist
, list
) {
173 list_del(&client
->list
);
174 if (client
->funcs
&& client
->funcs
->unregister
) {
175 client
->funcs
->unregister(client
);
177 drm_client_release(client
);
181 mutex_unlock(&dev
->clientlist_mutex
);
185 * drm_client_dev_hotplug - Send hotplug event to clients
188 * This function calls the &drm_client_funcs.hotplug callback on the attached clients.
190 * drm_kms_helper_hotplug_event() calls this function, so drivers that use it
191 * don't need to call this function themselves.
193 void drm_client_dev_hotplug(struct drm_device
*dev
)
195 struct drm_client_dev
*client
;
198 if (!drm_core_check_feature(dev
, DRIVER_MODESET
))
201 mutex_lock(&dev
->clientlist_mutex
);
202 list_for_each_entry(client
, &dev
->clientlist
, list
) {
203 if (!client
->funcs
|| !client
->funcs
->hotplug
)
206 ret
= client
->funcs
->hotplug(client
);
207 DRM_DEV_DEBUG_KMS(dev
->dev
, "%s: ret=%d\n", client
->name
, ret
);
209 mutex_unlock(&dev
->clientlist_mutex
);
211 EXPORT_SYMBOL(drm_client_dev_hotplug
);
213 void drm_client_dev_restore(struct drm_device
*dev
)
215 struct drm_client_dev
*client
;
218 if (!drm_core_check_feature(dev
, DRIVER_MODESET
))
221 mutex_lock(&dev
->clientlist_mutex
);
222 list_for_each_entry(client
, &dev
->clientlist
, list
) {
223 if (!client
->funcs
|| !client
->funcs
->restore
)
226 ret
= client
->funcs
->restore(client
);
227 DRM_DEV_DEBUG_KMS(dev
->dev
, "%s: ret=%d\n", client
->name
, ret
);
228 if (!ret
) /* The first one to return zero gets the privilege to restore */
231 mutex_unlock(&dev
->clientlist_mutex
);
234 static void drm_client_buffer_delete(struct drm_client_buffer
*buffer
)
236 struct drm_device
*dev
= buffer
->client
->dev
;
238 drm_gem_vunmap(buffer
->gem
, buffer
->vaddr
);
241 drm_gem_object_put_unlocked(buffer
->gem
);
244 drm_mode_destroy_dumb(dev
, buffer
->handle
, buffer
->client
->file
);
249 static struct drm_client_buffer
*
250 drm_client_buffer_create(struct drm_client_dev
*client
, u32 width
, u32 height
, u32 format
)
252 const struct drm_format_info
*info
= drm_format_info(format
);
253 struct drm_mode_create_dumb dumb_args
= { };
254 struct drm_device
*dev
= client
->dev
;
255 struct drm_client_buffer
*buffer
;
256 struct drm_gem_object
*obj
;
259 buffer
= kzalloc(sizeof(*buffer
), GFP_KERNEL
);
261 return ERR_PTR(-ENOMEM
);
263 buffer
->client
= client
;
265 dumb_args
.width
= width
;
266 dumb_args
.height
= height
;
267 dumb_args
.bpp
= info
->cpp
[0] * 8;
268 ret
= drm_mode_create_dumb(dev
, &dumb_args
, client
->file
);
272 buffer
->handle
= dumb_args
.handle
;
273 buffer
->pitch
= dumb_args
.pitch
;
275 obj
= drm_gem_object_lookup(client
->file
, dumb_args
.handle
);
286 drm_client_buffer_delete(buffer
);
292 * drm_client_buffer_vmap - Map DRM client buffer into address space
293 * @buffer: DRM client buffer
295 * This function maps a client buffer into kernel address space. If the
296 * buffer is already mapped, it returns the mapping's address.
298 * Client buffer mappings are not ref'counted. Each call to
299 * drm_client_buffer_vmap() should be followed by a call to
300 * drm_client_buffer_vunmap(); or the client buffer should be mapped
301 * throughout its lifetime.
304 * The mapped memory's address
306 void *drm_client_buffer_vmap(struct drm_client_buffer
*buffer
)
311 return buffer
->vaddr
;
314 * FIXME: The dependency on GEM here isn't required, we could
315 * convert the driver handle to a dma-buf instead and use the
316 * backend-agnostic dma-buf vmap support instead. This would
317 * require that the handle2fd prime ioctl is reworked to pull the
318 * fd_install step out of the driver backend hooks, to make that
319 * final step optional for internal users.
321 vaddr
= drm_gem_vmap(buffer
->gem
);
325 buffer
->vaddr
= vaddr
;
329 EXPORT_SYMBOL(drm_client_buffer_vmap
);
332 * drm_client_buffer_vunmap - Unmap DRM client buffer
333 * @buffer: DRM client buffer
335 * This function removes a client buffer's memory mapping. Calling this
336 * function is only required by clients that manage their buffer mappings
339 void drm_client_buffer_vunmap(struct drm_client_buffer
*buffer
)
341 drm_gem_vunmap(buffer
->gem
, buffer
->vaddr
);
342 buffer
->vaddr
= NULL
;
344 EXPORT_SYMBOL(drm_client_buffer_vunmap
);
346 static void drm_client_buffer_rmfb(struct drm_client_buffer
*buffer
)
353 ret
= drm_mode_rmfb(buffer
->client
->dev
, buffer
->fb
->base
.id
, buffer
->client
->file
);
355 DRM_DEV_ERROR(buffer
->client
->dev
->dev
,
356 "Error removing FB:%u (%d)\n", buffer
->fb
->base
.id
, ret
);
361 static int drm_client_buffer_addfb(struct drm_client_buffer
*buffer
,
362 u32 width
, u32 height
, u32 format
)
364 struct drm_client_dev
*client
= buffer
->client
;
365 struct drm_mode_fb_cmd fb_req
= { };
366 const struct drm_format_info
*info
;
369 info
= drm_format_info(format
);
370 fb_req
.bpp
= info
->cpp
[0] * 8;
371 fb_req
.depth
= info
->depth
;
372 fb_req
.width
= width
;
373 fb_req
.height
= height
;
374 fb_req
.handle
= buffer
->handle
;
375 fb_req
.pitch
= buffer
->pitch
;
377 ret
= drm_mode_addfb(client
->dev
, &fb_req
, client
->file
);
381 buffer
->fb
= drm_framebuffer_lookup(client
->dev
, buffer
->client
->file
, fb_req
.fb_id
);
382 if (WARN_ON(!buffer
->fb
))
385 /* drop the reference we picked up in framebuffer lookup */
386 drm_framebuffer_put(buffer
->fb
);
388 strscpy(buffer
->fb
->comm
, client
->name
, TASK_COMM_LEN
);
394 * drm_client_framebuffer_create - Create a client framebuffer
395 * @client: DRM client
396 * @width: Framebuffer width
397 * @height: Framebuffer height
398 * @format: Buffer format
400 * This function creates a &drm_client_buffer which consists of a
401 * &drm_framebuffer backed by a dumb buffer.
402 * Call drm_client_framebuffer_delete() to free the buffer.
405 * Pointer to a client buffer or an error pointer on failure.
407 struct drm_client_buffer
*
408 drm_client_framebuffer_create(struct drm_client_dev
*client
, u32 width
, u32 height
, u32 format
)
410 struct drm_client_buffer
*buffer
;
413 buffer
= drm_client_buffer_create(client
, width
, height
, format
);
417 ret
= drm_client_buffer_addfb(buffer
, width
, height
, format
);
419 drm_client_buffer_delete(buffer
);
425 EXPORT_SYMBOL(drm_client_framebuffer_create
);
428 * drm_client_framebuffer_delete - Delete a client framebuffer
429 * @buffer: DRM client buffer (can be NULL)
431 void drm_client_framebuffer_delete(struct drm_client_buffer
*buffer
)
436 drm_client_buffer_rmfb(buffer
);
437 drm_client_buffer_delete(buffer
);
439 EXPORT_SYMBOL(drm_client_framebuffer_delete
);
441 #ifdef CONFIG_DEBUG_FS
442 static int drm_client_debugfs_internal_clients(struct seq_file
*m
, void *data
)
444 struct drm_info_node
*node
= m
->private;
445 struct drm_device
*dev
= node
->minor
->dev
;
446 struct drm_printer p
= drm_seq_file_printer(m
);
447 struct drm_client_dev
*client
;
449 mutex_lock(&dev
->clientlist_mutex
);
450 list_for_each_entry(client
, &dev
->clientlist
, list
)
451 drm_printf(&p
, "%s\n", client
->name
);
452 mutex_unlock(&dev
->clientlist_mutex
);
457 static const struct drm_info_list drm_client_debugfs_list
[] = {
458 { "internal_clients", drm_client_debugfs_internal_clients
, 0 },
461 int drm_client_debugfs_init(struct drm_minor
*minor
)
463 return drm_debugfs_create_files(drm_client_debugfs_list
,
464 ARRAY_SIZE(drm_client_debugfs_list
),
465 minor
->debugfs_root
, minor
);