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_gem.h>
19 #include <drm/drm_mode.h>
20 #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.
30 * Currently it's only partially implemented, just enough to support fbdev.
32 * GEM drivers which provide a GEM based dumb buffer with a virtual address are supported.
35 static int drm_client_open(struct drm_client_dev
*client
)
37 struct drm_device
*dev
= client
->dev
;
38 struct drm_file
*file
;
40 file
= drm_file_alloc(dev
->primary
);
44 mutex_lock(&dev
->filelist_mutex
);
45 list_add(&file
->lhead
, &dev
->filelist_internal
);
46 mutex_unlock(&dev
->filelist_mutex
);
53 static void drm_client_close(struct drm_client_dev
*client
)
55 struct drm_device
*dev
= client
->dev
;
57 mutex_lock(&dev
->filelist_mutex
);
58 list_del(&client
->file
->lhead
);
59 mutex_unlock(&dev
->filelist_mutex
);
61 drm_file_free(client
->file
);
63 EXPORT_SYMBOL(drm_client_close
);
66 * drm_client_init - Initialise a DRM client
70 * @funcs: DRM client functions (optional)
72 * This initialises the client and opens a &drm_file. Use drm_client_add() 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_open(client
);
104 module_put(funcs
->owner
);
108 EXPORT_SYMBOL(drm_client_init
);
111 * drm_client_add - Add client to the device list
112 * @client: DRM client
114 * Add the client to the &drm_device client list to activate its callbacks.
115 * @client must be initialized by a call to drm_client_init(). After
116 * drm_client_add() it is no longer permissible to call drm_client_release()
117 * directly (outside the unregister callback), instead cleanup will happen
118 * automatically on driver unload.
120 void drm_client_add(struct drm_client_dev
*client
)
122 struct drm_device
*dev
= client
->dev
;
124 mutex_lock(&dev
->clientlist_mutex
);
125 list_add(&client
->list
, &dev
->clientlist
);
126 mutex_unlock(&dev
->clientlist_mutex
);
128 EXPORT_SYMBOL(drm_client_add
);
131 * drm_client_release - Release DRM client resources
132 * @client: DRM client
134 * Releases resources by closing the &drm_file that was opened by drm_client_init().
135 * It is called automatically if the &drm_client_funcs.unregister callback is _not_ set.
137 * This function should only be called from the unregister callback. An exception
138 * is fbdev which cannot free the buffer if userspace has open file descriptors.
141 * Clients cannot initiate a release by themselves. This is done to keep the code simple.
142 * The driver has to be unloaded before the client can be unloaded.
144 void drm_client_release(struct drm_client_dev
*client
)
146 struct drm_device
*dev
= client
->dev
;
148 DRM_DEV_DEBUG_KMS(dev
->dev
, "%s\n", client
->name
);
150 drm_client_close(client
);
153 module_put(client
->funcs
->owner
);
155 EXPORT_SYMBOL(drm_client_release
);
157 void drm_client_dev_unregister(struct drm_device
*dev
)
159 struct drm_client_dev
*client
, *tmp
;
161 if (!drm_core_check_feature(dev
, DRIVER_MODESET
))
164 mutex_lock(&dev
->clientlist_mutex
);
165 list_for_each_entry_safe(client
, tmp
, &dev
->clientlist
, list
) {
166 list_del(&client
->list
);
167 if (client
->funcs
&& client
->funcs
->unregister
) {
168 client
->funcs
->unregister(client
);
170 drm_client_release(client
);
174 mutex_unlock(&dev
->clientlist_mutex
);
178 * drm_client_dev_hotplug - Send hotplug event to clients
181 * This function calls the &drm_client_funcs.hotplug callback on the attached clients.
183 * drm_kms_helper_hotplug_event() calls this function, so drivers that use it
184 * don't need to call this function themselves.
186 void drm_client_dev_hotplug(struct drm_device
*dev
)
188 struct drm_client_dev
*client
;
191 if (!drm_core_check_feature(dev
, DRIVER_MODESET
))
194 mutex_lock(&dev
->clientlist_mutex
);
195 list_for_each_entry(client
, &dev
->clientlist
, list
) {
196 if (!client
->funcs
|| !client
->funcs
->hotplug
)
199 ret
= client
->funcs
->hotplug(client
);
200 DRM_DEV_DEBUG_KMS(dev
->dev
, "%s: ret=%d\n", client
->name
, ret
);
202 mutex_unlock(&dev
->clientlist_mutex
);
204 EXPORT_SYMBOL(drm_client_dev_hotplug
);
206 void drm_client_dev_restore(struct drm_device
*dev
)
208 struct drm_client_dev
*client
;
211 if (!drm_core_check_feature(dev
, DRIVER_MODESET
))
214 mutex_lock(&dev
->clientlist_mutex
);
215 list_for_each_entry(client
, &dev
->clientlist
, list
) {
216 if (!client
->funcs
|| !client
->funcs
->restore
)
219 ret
= client
->funcs
->restore(client
);
220 DRM_DEV_DEBUG_KMS(dev
->dev
, "%s: ret=%d\n", client
->name
, ret
);
221 if (!ret
) /* The first one to return zero gets the privilege to restore */
224 mutex_unlock(&dev
->clientlist_mutex
);
227 static void drm_client_buffer_delete(struct drm_client_buffer
*buffer
)
229 struct drm_device
*dev
= buffer
->client
->dev
;
231 drm_gem_vunmap(buffer
->gem
, buffer
->vaddr
);
234 drm_gem_object_put_unlocked(buffer
->gem
);
237 drm_mode_destroy_dumb(dev
, buffer
->handle
, buffer
->client
->file
);
242 static struct drm_client_buffer
*
243 drm_client_buffer_create(struct drm_client_dev
*client
, u32 width
, u32 height
, u32 format
)
245 struct drm_mode_create_dumb dumb_args
= { };
246 struct drm_device
*dev
= client
->dev
;
247 struct drm_client_buffer
*buffer
;
248 struct drm_gem_object
*obj
;
252 buffer
= kzalloc(sizeof(*buffer
), GFP_KERNEL
);
254 return ERR_PTR(-ENOMEM
);
256 buffer
->client
= client
;
258 dumb_args
.width
= width
;
259 dumb_args
.height
= height
;
260 dumb_args
.bpp
= drm_format_plane_cpp(format
, 0) * 8;
261 ret
= drm_mode_create_dumb(dev
, &dumb_args
, client
->file
);
265 buffer
->handle
= dumb_args
.handle
;
266 buffer
->pitch
= dumb_args
.pitch
;
268 obj
= drm_gem_object_lookup(client
->file
, dumb_args
.handle
);
277 * FIXME: The dependency on GEM here isn't required, we could
278 * convert the driver handle to a dma-buf instead and use the
279 * backend-agnostic dma-buf vmap support instead. This would
280 * require that the handle2fd prime ioctl is reworked to pull the
281 * fd_install step out of the driver backend hooks, to make that
282 * final step optional for internal users.
284 vaddr
= drm_gem_vmap(obj
);
286 ret
= PTR_ERR(vaddr
);
290 buffer
->vaddr
= vaddr
;
295 drm_client_buffer_delete(buffer
);
300 static void drm_client_buffer_rmfb(struct drm_client_buffer
*buffer
)
307 ret
= drm_mode_rmfb(buffer
->client
->dev
, buffer
->fb
->base
.id
, buffer
->client
->file
);
309 DRM_DEV_ERROR(buffer
->client
->dev
->dev
,
310 "Error removing FB:%u (%d)\n", buffer
->fb
->base
.id
, ret
);
315 static int drm_client_buffer_addfb(struct drm_client_buffer
*buffer
,
316 u32 width
, u32 height
, u32 format
)
318 struct drm_client_dev
*client
= buffer
->client
;
319 struct drm_mode_fb_cmd fb_req
= { };
320 const struct drm_format_info
*info
;
323 info
= drm_format_info(format
);
324 fb_req
.bpp
= info
->cpp
[0] * 8;
325 fb_req
.depth
= info
->depth
;
326 fb_req
.width
= width
;
327 fb_req
.height
= height
;
328 fb_req
.handle
= buffer
->handle
;
329 fb_req
.pitch
= buffer
->pitch
;
331 ret
= drm_mode_addfb(client
->dev
, &fb_req
, client
->file
);
335 buffer
->fb
= drm_framebuffer_lookup(client
->dev
, buffer
->client
->file
, fb_req
.fb_id
);
336 if (WARN_ON(!buffer
->fb
))
339 /* drop the reference we picked up in framebuffer lookup */
340 drm_framebuffer_put(buffer
->fb
);
342 strscpy(buffer
->fb
->comm
, client
->name
, TASK_COMM_LEN
);
348 * drm_client_framebuffer_create - Create a client framebuffer
349 * @client: DRM client
350 * @width: Framebuffer width
351 * @height: Framebuffer height
352 * @format: Buffer format
354 * This function creates a &drm_client_buffer which consists of a
355 * &drm_framebuffer backed by a dumb buffer.
356 * Call drm_client_framebuffer_delete() to free the buffer.
359 * Pointer to a client buffer or an error pointer on failure.
361 struct drm_client_buffer
*
362 drm_client_framebuffer_create(struct drm_client_dev
*client
, u32 width
, u32 height
, u32 format
)
364 struct drm_client_buffer
*buffer
;
367 buffer
= drm_client_buffer_create(client
, width
, height
, format
);
371 ret
= drm_client_buffer_addfb(buffer
, width
, height
, format
);
373 drm_client_buffer_delete(buffer
);
379 EXPORT_SYMBOL(drm_client_framebuffer_create
);
382 * drm_client_framebuffer_delete - Delete a client framebuffer
383 * @buffer: DRM client buffer (can be NULL)
385 void drm_client_framebuffer_delete(struct drm_client_buffer
*buffer
)
390 drm_client_buffer_rmfb(buffer
);
391 drm_client_buffer_delete(buffer
);
393 EXPORT_SYMBOL(drm_client_framebuffer_delete
);
395 #ifdef CONFIG_DEBUG_FS
396 static int drm_client_debugfs_internal_clients(struct seq_file
*m
, void *data
)
398 struct drm_info_node
*node
= m
->private;
399 struct drm_device
*dev
= node
->minor
->dev
;
400 struct drm_printer p
= drm_seq_file_printer(m
);
401 struct drm_client_dev
*client
;
403 mutex_lock(&dev
->clientlist_mutex
);
404 list_for_each_entry(client
, &dev
->clientlist
, list
)
405 drm_printf(&p
, "%s\n", client
->name
);
406 mutex_unlock(&dev
->clientlist_mutex
);
411 static const struct drm_info_list drm_client_debugfs_list
[] = {
412 { "internal_clients", drm_client_debugfs_internal_clients
, 0 },
415 int drm_client_debugfs_init(struct drm_minor
*minor
)
417 return drm_debugfs_create_files(drm_client_debugfs_list
,
418 ARRAY_SIZE(drm_client_debugfs_list
),
419 minor
->debugfs_root
, minor
);