Contributors: 24
| Author |
Tokens |
Token Proportion |
Commits |
Commit Proportion |
| Noralf Trönnes |
404 |
46.71% |
3 |
6.25% |
| Thomas Zimmermann |
302 |
34.91% |
10 |
20.83% |
| Ben Skeggs |
30 |
3.47% |
1 |
2.08% |
| Dave Airlie |
25 |
2.89% |
4 |
8.33% |
| Maxime Ripard |
18 |
2.08% |
1 |
2.08% |
| Daniel Vetter |
17 |
1.97% |
7 |
14.58% |
| Thomas Wood |
12 |
1.39% |
1 |
2.08% |
| Andrzej Hajda |
11 |
1.27% |
1 |
2.08% |
| Maíra Canal |
7 |
0.81% |
1 |
2.08% |
| Christian König |
6 |
0.69% |
1 |
2.08% |
| David Herrmann |
5 |
0.58% |
2 |
4.17% |
| Jani Nikula |
4 |
0.46% |
3 |
6.25% |
| Peter Wu |
4 |
0.46% |
1 |
2.08% |
| Chris Wilson |
3 |
0.35% |
1 |
2.08% |
| Ben Gamari |
2 |
0.23% |
1 |
2.08% |
| Tejun Heo |
2 |
0.23% |
1 |
2.08% |
| Eric Anholt |
2 |
0.23% |
1 |
2.08% |
| Prathyush K |
2 |
0.23% |
1 |
2.08% |
| Maarten Lankhorst |
2 |
0.23% |
1 |
2.08% |
| Wambui Karuga |
2 |
0.23% |
2 |
4.17% |
| Sam Ravnborg |
2 |
0.23% |
1 |
2.08% |
| Emmanuel Vadot |
1 |
0.12% |
1 |
2.08% |
| Laurent Pinchart |
1 |
0.12% |
1 |
2.08% |
| Tomeu Vizoso |
1 |
0.12% |
1 |
2.08% |
| Total |
865 |
|
48 |
|
// SPDX-License-Identifier: GPL-2.0 or MIT
/*
* Copyright 2018 Noralf Trønnes
*/
#include <linux/list.h>
#include <linux/mutex.h>
#include <linux/seq_file.h>
#include <drm/drm_client.h>
#include <drm/drm_client_event.h>
#include <drm/drm_debugfs.h>
#include <drm/drm_device.h>
#include <drm/drm_drv.h>
#include <drm/drm_print.h>
#include "drm_internal.h"
/**
* drm_client_dev_unregister - Unregister clients
* @dev: DRM device
*
* This function releases all clients by calling each client's
* &drm_client_funcs.unregister callback. The callback function
* is responsibe for releaseing all resources including the client
* itself.
*
* The helper drm_dev_unregister() calls this function. Drivers
* that use it don't need to call this function themselves.
*/
void drm_client_dev_unregister(struct drm_device *dev)
{
struct drm_client_dev *client, *tmp;
if (!drm_core_check_feature(dev, DRIVER_MODESET))
return;
mutex_lock(&dev->clientlist_mutex);
list_for_each_entry_safe(client, tmp, &dev->clientlist, list) {
list_del(&client->list);
if (client->funcs && client->funcs->unregister) {
client->funcs->unregister(client);
} else {
drm_client_release(client);
kfree(client);
}
}
mutex_unlock(&dev->clientlist_mutex);
}
EXPORT_SYMBOL(drm_client_dev_unregister);
static void drm_client_hotplug(struct drm_client_dev *client)
{
struct drm_device *dev = client->dev;
int ret;
if (!client->funcs || !client->funcs->hotplug)
return;
if (client->hotplug_failed)
return;
if (client->suspended) {
client->hotplug_pending = true;
return;
}
client->hotplug_pending = false;
ret = client->funcs->hotplug(client);
drm_dbg_kms(dev, "%s: ret=%d\n", client->name, ret);
if (ret)
client->hotplug_failed = true;
}
/**
* drm_client_dev_hotplug - Send hotplug event to clients
* @dev: DRM device
*
* This function calls the &drm_client_funcs.hotplug callback on the attached clients.
*
* drm_kms_helper_hotplug_event() calls this function, so drivers that use it
* don't need to call this function themselves.
*/
void drm_client_dev_hotplug(struct drm_device *dev)
{
struct drm_client_dev *client;
if (!drm_core_check_feature(dev, DRIVER_MODESET))
return;
if (!dev->mode_config.num_connector) {
drm_dbg_kms(dev, "No connectors found, will not send hotplug events!\n");
return;
}
mutex_lock(&dev->clientlist_mutex);
list_for_each_entry(client, &dev->clientlist, list)
drm_client_hotplug(client);
mutex_unlock(&dev->clientlist_mutex);
}
EXPORT_SYMBOL(drm_client_dev_hotplug);
void drm_client_dev_restore(struct drm_device *dev)
{
struct drm_client_dev *client;
int ret;
if (!drm_core_check_feature(dev, DRIVER_MODESET))
return;
mutex_lock(&dev->clientlist_mutex);
list_for_each_entry(client, &dev->clientlist, list) {
if (!client->funcs || !client->funcs->restore)
continue;
ret = client->funcs->restore(client);
drm_dbg_kms(dev, "%s: ret=%d\n", client->name, ret);
if (!ret) /* The first one to return zero gets the privilege to restore */
break;
}
mutex_unlock(&dev->clientlist_mutex);
}
static int drm_client_suspend(struct drm_client_dev *client, bool holds_console_lock)
{
struct drm_device *dev = client->dev;
int ret = 0;
if (drm_WARN_ON_ONCE(dev, client->suspended))
return 0;
if (client->funcs && client->funcs->suspend)
ret = client->funcs->suspend(client, holds_console_lock);
drm_dbg_kms(dev, "%s: ret=%d\n", client->name, ret);
client->suspended = true;
return ret;
}
void drm_client_dev_suspend(struct drm_device *dev, bool holds_console_lock)
{
struct drm_client_dev *client;
mutex_lock(&dev->clientlist_mutex);
list_for_each_entry(client, &dev->clientlist, list) {
if (!client->suspended)
drm_client_suspend(client, holds_console_lock);
}
mutex_unlock(&dev->clientlist_mutex);
}
EXPORT_SYMBOL(drm_client_dev_suspend);
static int drm_client_resume(struct drm_client_dev *client, bool holds_console_lock)
{
struct drm_device *dev = client->dev;
int ret = 0;
if (drm_WARN_ON_ONCE(dev, !client->suspended))
return 0;
if (client->funcs && client->funcs->resume)
ret = client->funcs->resume(client, holds_console_lock);
drm_dbg_kms(dev, "%s: ret=%d\n", client->name, ret);
client->suspended = false;
if (client->hotplug_pending)
drm_client_hotplug(client);
return ret;
}
void drm_client_dev_resume(struct drm_device *dev, bool holds_console_lock)
{
struct drm_client_dev *client;
mutex_lock(&dev->clientlist_mutex);
list_for_each_entry(client, &dev->clientlist, list) {
if (client->suspended)
drm_client_resume(client, holds_console_lock);
}
mutex_unlock(&dev->clientlist_mutex);
}
EXPORT_SYMBOL(drm_client_dev_resume);
#ifdef CONFIG_DEBUG_FS
static int drm_client_debugfs_internal_clients(struct seq_file *m, void *data)
{
struct drm_debugfs_entry *entry = m->private;
struct drm_device *dev = entry->dev;
struct drm_printer p = drm_seq_file_printer(m);
struct drm_client_dev *client;
mutex_lock(&dev->clientlist_mutex);
list_for_each_entry(client, &dev->clientlist, list)
drm_printf(&p, "%s\n", client->name);
mutex_unlock(&dev->clientlist_mutex);
return 0;
}
static const struct drm_debugfs_info drm_client_debugfs_list[] = {
{ "internal_clients", drm_client_debugfs_internal_clients, 0 },
};
void drm_client_debugfs_init(struct drm_device *dev)
{
drm_debugfs_add_files(dev, drm_client_debugfs_list,
ARRAY_SIZE(drm_client_debugfs_list));
}
#endif