1// SPDX-License-Identifier: GPL-2.0 or MIT
  2/*
  3 * Copyright 2018 Noralf Trønnes
  4 */
  5
  6#include <linux/dma-buf-map.h>
  7#include <linux/list.h>
  8#include <linux/module.h>
  9#include <linux/mutex.h>
 10#include <linux/seq_file.h>
 11#include <linux/slab.h>
 12
 13#include <drm/drm_client.h>
 14#include <drm/drm_debugfs.h>
 15#include <drm/drm_device.h>
 16#include <drm/drm_drv.h>
 17#include <drm/drm_file.h>
 18#include <drm/drm_fourcc.h>
 19#include <drm/drm_framebuffer.h>
 20#include <drm/drm_gem.h>
 21#include <drm/drm_mode.h>
 22#include <drm/drm_print.h>
 23
 24#include "drm_crtc_internal.h"
 25#include "drm_internal.h"
 26
 27/**
 28 * DOC: overview
 29 *
 30 * This library provides support for clients running in the kernel like fbdev and bootsplash.
 31 *
 32 * GEM drivers which provide a GEM based dumb buffer with a virtual address are supported.
 33 */
 34
 35static int drm_client_open(struct drm_client_dev *client)
 36{
 37	struct drm_device *dev = client->dev;
 38	struct drm_file *file;
 39
 40	file = drm_file_alloc(dev->primary);
 41	if (IS_ERR(file))
 42		return PTR_ERR(file);
 43
 44	mutex_lock(&dev->filelist_mutex);
 45	list_add(&file->lhead, &dev->filelist_internal);
 46	mutex_unlock(&dev->filelist_mutex);
 47
 48	client->file = file;
 49
 50	return 0;
 51}
 52
 53static void drm_client_close(struct drm_client_dev *client)
 54{
 55	struct drm_device *dev = client->dev;
 56
 57	mutex_lock(&dev->filelist_mutex);
 58	list_del(&client->file->lhead);
 59	mutex_unlock(&dev->filelist_mutex);
 60
 61	drm_file_free(client->file);
 62}
 63
 64/**
 65 * drm_client_init - Initialise a DRM client
 66 * @dev: DRM device
 67 * @client: DRM client
 68 * @name: Client name
 69 * @funcs: DRM client functions (optional)
 70 *
 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().
 75 *
 76 * Returns:
 77 * Zero on success or negative error code on failure.
 78 */
 79int drm_client_init(struct drm_device *dev, struct drm_client_dev *client,
 80		    const char *name, const struct drm_client_funcs *funcs)
 81{
 82	int ret;
 83
 84	if (!drm_core_check_feature(dev, DRIVER_MODESET) || !dev->driver->dumb_create)
 85		return -EOPNOTSUPP;
 86
 87	if (funcs && !try_module_get(funcs->owner))
 88		return -ENODEV;
 89
 90	client->dev = dev;
 91	client->name = name;
 92	client->funcs = funcs;
 93
 94	ret = drm_client_modeset_create(client);
 95	if (ret)
 96		goto err_put_module;
 97
 98	ret = drm_client_open(client);
 99	if (ret)
100		goto err_free;
101
102	drm_dev_get(dev);
103
104	return 0;
105
106err_free:
107	drm_client_modeset_free(client);
108err_put_module:
109	if (funcs)
110		module_put(funcs->owner);
111
112	return ret;
113}
114EXPORT_SYMBOL(drm_client_init);
115
116/**
117 * drm_client_register - Register client
118 * @client: DRM client
119 *
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.
125 */
126void drm_client_register(struct drm_client_dev *client)
127{
128	struct drm_device *dev = client->dev;
129
130	mutex_lock(&dev->clientlist_mutex);
131	list_add(&client->list, &dev->clientlist);
132	mutex_unlock(&dev->clientlist_mutex);
133}
134EXPORT_SYMBOL(drm_client_register);
135
136/**
137 * drm_client_release - Release DRM client resources
138 * @client: DRM client
139 *
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.
142 *
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.
145 *
146 * Note:
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.
149 */
150void drm_client_release(struct drm_client_dev *client)
151{
152	struct drm_device *dev = client->dev;
153
154	drm_dbg_kms(dev, "%s\n", client->name);
155
156	drm_client_modeset_free(client);
157	drm_client_close(client);
158	drm_dev_put(dev);
159	if (client->funcs)
160		module_put(client->funcs->owner);
161}
162EXPORT_SYMBOL(drm_client_release);
163
164void drm_client_dev_unregister(struct drm_device *dev)
165{
166	struct drm_client_dev *client, *tmp;
167
168	if (!drm_core_check_feature(dev, DRIVER_MODESET))
169		return;
170
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);
176		} else {
177			drm_client_release(client);
178			kfree(client);
179		}
180	}
181	mutex_unlock(&dev->clientlist_mutex);
182}
183
184/**
185 * drm_client_dev_hotplug - Send hotplug event to clients
186 * @dev: DRM device
187 *
188 * This function calls the &drm_client_funcs.hotplug callback on the attached clients.
189 *
190 * drm_kms_helper_hotplug_event() calls this function, so drivers that use it
191 * don't need to call this function themselves.
192 */
193void drm_client_dev_hotplug(struct drm_device *dev)
194{
195	struct drm_client_dev *client;
196	int ret;
197
198	if (!drm_core_check_feature(dev, DRIVER_MODESET))
199		return;
200
201	mutex_lock(&dev->clientlist_mutex);
202	list_for_each_entry(client, &dev->clientlist, list) {
203		if (!client->funcs || !client->funcs->hotplug)
204			continue;
205
206		ret = client->funcs->hotplug(client);
207		drm_dbg_kms(dev, "%s: ret=%d\n", client->name, ret);
208	}
209	mutex_unlock(&dev->clientlist_mutex);
210}
211EXPORT_SYMBOL(drm_client_dev_hotplug);
212
213void drm_client_dev_restore(struct drm_device *dev)
214{
215	struct drm_client_dev *client;
216	int ret;
217
218	if (!drm_core_check_feature(dev, DRIVER_MODESET))
219		return;
220
221	mutex_lock(&dev->clientlist_mutex);
222	list_for_each_entry(client, &dev->clientlist, list) {
223		if (!client->funcs || !client->funcs->restore)
224			continue;
225
226		ret = client->funcs->restore(client);
227		drm_dbg_kms(dev, "%s: ret=%d\n", client->name, ret);
228		if (!ret) /* The first one to return zero gets the privilege to restore */
229			break;
230	}
231	mutex_unlock(&dev->clientlist_mutex);
232}
233
234static void drm_client_buffer_delete(struct drm_client_buffer *buffer)
235{
236	struct drm_device *dev = buffer->client->dev;
237
238	drm_gem_vunmap(buffer->gem, &buffer->map);
239
240	if (buffer->gem)
241		drm_gem_object_put(buffer->gem);
242
243	if (buffer->handle)
244		drm_mode_destroy_dumb(dev, buffer->handle, buffer->client->file);
245
246	kfree(buffer);
247}
248
249static struct drm_client_buffer *
250drm_client_buffer_create(struct drm_client_dev *client, u32 width, u32 height, u32 format)
251{
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;
257	int ret;
258
259	buffer = kzalloc(sizeof(*buffer), GFP_KERNEL);
260	if (!buffer)
261		return ERR_PTR(-ENOMEM);
262
263	buffer->client = client;
264
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);
269	if (ret)
270		goto err_delete;
271
272	buffer->handle = dumb_args.handle;
273	buffer->pitch = dumb_args.pitch;
274
275	obj = drm_gem_object_lookup(client->file, dumb_args.handle);
276	if (!obj)  {
277		ret = -ENOENT;
278		goto err_delete;
279	}
280
281	buffer->gem = obj;
282
283	return buffer;
284
285err_delete:
286	drm_client_buffer_delete(buffer);
287
288	return ERR_PTR(ret);
289}
290
291/**
292 * drm_client_buffer_vmap - Map DRM client buffer into address space
293 * @buffer: DRM client buffer
294 * @map_copy: Returns the mapped memory's address
295 *
296 * This function maps a client buffer into kernel address space. If the
297 * buffer is already mapped, it returns the existing mapping's address.
298 *
299 * Client buffer mappings are not ref'counted. Each call to
300 * drm_client_buffer_vmap() should be followed by a call to
301 * drm_client_buffer_vunmap(); or the client buffer should be mapped
302 * throughout its lifetime.
303 *
304 * The returned address is a copy of the internal value. In contrast to
305 * other vmap interfaces, you don't need it for the client's vunmap
306 * function. So you can modify it at will during blit and draw operations.
307 *
308 * Returns:
309 *	0 on success, or a negative errno code otherwise.
310 */
311int
312drm_client_buffer_vmap(struct drm_client_buffer *buffer, struct dma_buf_map *map_copy)
313{
314	struct dma_buf_map *map = &buffer->map;
315	int ret;
316
317	/*
318	 * FIXME: The dependency on GEM here isn't required, we could
319	 * convert the driver handle to a dma-buf instead and use the
320	 * backend-agnostic dma-buf vmap support instead. This would
321	 * require that the handle2fd prime ioctl is reworked to pull the
322	 * fd_install step out of the driver backend hooks, to make that
323	 * final step optional for internal users.
324	 */
325	ret = drm_gem_vmap(buffer->gem, map);
326	if (ret)
327		return ret;
328
329	*map_copy = *map;
330
331	return 0;
332}
333EXPORT_SYMBOL(drm_client_buffer_vmap);
334
335/**
336 * drm_client_buffer_vunmap - Unmap DRM client buffer
337 * @buffer: DRM client buffer
338 *
339 * This function removes a client buffer's memory mapping. Calling this
340 * function is only required by clients that manage their buffer mappings
341 * by themselves.
342 */
343void drm_client_buffer_vunmap(struct drm_client_buffer *buffer)
344{
345	struct dma_buf_map *map = &buffer->map;
346
347	drm_gem_vunmap(buffer->gem, map);
348}
349EXPORT_SYMBOL(drm_client_buffer_vunmap);
350
351static void drm_client_buffer_rmfb(struct drm_client_buffer *buffer)
352{
353	int ret;
354
355	if (!buffer->fb)
356		return;
357
358	ret = drm_mode_rmfb(buffer->client->dev, buffer->fb->base.id, buffer->client->file);
359	if (ret)
360		drm_err(buffer->client->dev,
361			"Error removing FB:%u (%d)\n", buffer->fb->base.id, ret);
362
363	buffer->fb = NULL;
364}
365
366static int drm_client_buffer_addfb(struct drm_client_buffer *buffer,
367				   u32 width, u32 height, u32 format)
368{
369	struct drm_client_dev *client = buffer->client;
370	struct drm_mode_fb_cmd fb_req = { };
371	const struct drm_format_info *info;
372	int ret;
373
374	info = drm_format_info(format);
375	fb_req.bpp = info->cpp[0] * 8;
376	fb_req.depth = info->depth;
377	fb_req.width = width;
378	fb_req.height = height;
379	fb_req.handle = buffer->handle;
380	fb_req.pitch = buffer->pitch;
381
382	ret = drm_mode_addfb(client->dev, &fb_req, client->file);
383	if (ret)
384		return ret;
385
386	buffer->fb = drm_framebuffer_lookup(client->dev, buffer->client->file, fb_req.fb_id);
387	if (WARN_ON(!buffer->fb))
388		return -ENOENT;
389
390	/* drop the reference we picked up in framebuffer lookup */
391	drm_framebuffer_put(buffer->fb);
392
393	strscpy(buffer->fb->comm, client->name, TASK_COMM_LEN);
394
395	return 0;
396}
397
398/**
399 * drm_client_framebuffer_create - Create a client framebuffer
400 * @client: DRM client
401 * @width: Framebuffer width
402 * @height: Framebuffer height
403 * @format: Buffer format
404 *
405 * This function creates a &drm_client_buffer which consists of a
406 * &drm_framebuffer backed by a dumb buffer.
407 * Call drm_client_framebuffer_delete() to free the buffer.
408 *
409 * Returns:
410 * Pointer to a client buffer or an error pointer on failure.
411 */
412struct drm_client_buffer *
413drm_client_framebuffer_create(struct drm_client_dev *client, u32 width, u32 height, u32 format)
414{
415	struct drm_client_buffer *buffer;
416	int ret;
417
418	buffer = drm_client_buffer_create(client, width, height, format);
419	if (IS_ERR(buffer))
420		return buffer;
421
422	ret = drm_client_buffer_addfb(buffer, width, height, format);
423	if (ret) {
424		drm_client_buffer_delete(buffer);
425		return ERR_PTR(ret);
426	}
427
428	return buffer;
429}
430EXPORT_SYMBOL(drm_client_framebuffer_create);
431
432/**
433 * drm_client_framebuffer_delete - Delete a client framebuffer
434 * @buffer: DRM client buffer (can be NULL)
435 */
436void drm_client_framebuffer_delete(struct drm_client_buffer *buffer)
437{
438	if (!buffer)
439		return;
440
441	drm_client_buffer_rmfb(buffer);
442	drm_client_buffer_delete(buffer);
443}
444EXPORT_SYMBOL(drm_client_framebuffer_delete);
445
446/**
447 * drm_client_framebuffer_flush - Manually flush client framebuffer
448 * @buffer: DRM client buffer (can be NULL)
449 * @rect: Damage rectangle (if NULL flushes all)
450 *
451 * This calls &drm_framebuffer_funcs->dirty (if present) to flush buffer changes
452 * for drivers that need it.
453 *
454 * Returns:
455 * Zero on success or negative error code on failure.
456 */
457int drm_client_framebuffer_flush(struct drm_client_buffer *buffer, struct drm_rect *rect)
458{
459	if (!buffer || !buffer->fb || !buffer->fb->funcs->dirty)
460		return 0;
461
462	if (rect) {
463		struct drm_clip_rect clip = {
464			.x1 = rect->x1,
465			.y1 = rect->y1,
466			.x2 = rect->x2,
467			.y2 = rect->y2,
468		};
469
470		return buffer->fb->funcs->dirty(buffer->fb, buffer->client->file,
471						0, 0, &clip, 1);
472	}
473
474	return buffer->fb->funcs->dirty(buffer->fb, buffer->client->file,
475					0, 0, NULL, 0);
476}
477EXPORT_SYMBOL(drm_client_framebuffer_flush);
478
479#ifdef CONFIG_DEBUG_FS
480static int drm_client_debugfs_internal_clients(struct seq_file *m, void *data)
481{
482	struct drm_info_node *node = m->private;
483	struct drm_device *dev = node->minor->dev;
484	struct drm_printer p = drm_seq_file_printer(m);
485	struct drm_client_dev *client;
486
487	mutex_lock(&dev->clientlist_mutex);
488	list_for_each_entry(client, &dev->clientlist, list)
489		drm_printf(&p, "%s\n", client->name);
490	mutex_unlock(&dev->clientlist_mutex);
491
492	return 0;
493}
494
495static const struct drm_info_list drm_client_debugfs_list[] = {
496	{ "internal_clients", drm_client_debugfs_internal_clients, 0 },
497};
498
499void drm_client_debugfs_init(struct drm_minor *minor)
500{
501	drm_debugfs_create_files(drm_client_debugfs_list,
502				 ARRAY_SIZE(drm_client_debugfs_list),
503				 minor->debugfs_root, minor);
504}
505#endif