1 // SPDX-License-Identifier: GPL-2.0 or MIT 2 /* 3 * Copyright 2018 Noralf Trønnes 4 */ 5 6 #include <linux/export.h> 7 #include <linux/list.h> 8 #include <linux/mutex.h> 9 #include <linux/seq_file.h> 10 11 #include <drm/drm_client.h> 12 #include <drm/drm_client_event.h> 13 #include <drm/drm_debugfs.h> 14 #include <drm/drm_device.h> 15 #include <drm/drm_drv.h> 16 #include <drm/drm_print.h> 17 18 #include "drm_internal.h" 19 20 /** 21 * drm_client_dev_unregister - Unregister clients 22 * @dev: DRM device 23 * 24 * This function releases all clients by calling each client's 25 * &drm_client_funcs.unregister callback. The callback function 26 * is responsibe for releaseing all resources including the client 27 * itself. 28 * 29 * The helper drm_dev_unregister() calls this function. Drivers 30 * that use it don't need to call this function themselves. 31 */ 32 void drm_client_dev_unregister(struct drm_device *dev) 33 { 34 struct drm_client_dev *client, *tmp; 35 36 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 37 return; 38 39 mutex_lock(&dev->clientlist_mutex); 40 list_for_each_entry_safe(client, tmp, &dev->clientlist, list) { 41 list_del(&client->list); 42 if (client->funcs && client->funcs->unregister) { 43 client->funcs->unregister(client); 44 } else { 45 drm_client_release(client); 46 kfree(client); 47 } 48 } 49 mutex_unlock(&dev->clientlist_mutex); 50 } 51 EXPORT_SYMBOL(drm_client_dev_unregister); 52 53 static void drm_client_hotplug(struct drm_client_dev *client) 54 { 55 struct drm_device *dev = client->dev; 56 int ret; 57 58 if (!client->funcs || !client->funcs->hotplug) 59 return; 60 61 if (client->hotplug_failed) 62 return; 63 64 if (client->suspended) { 65 client->hotplug_pending = true; 66 return; 67 } 68 69 client->hotplug_pending = false; 70 ret = client->funcs->hotplug(client); 71 drm_dbg_kms(dev, "%s: ret=%d\n", client->name, ret); 72 if (ret) 73 client->hotplug_failed = true; 74 } 75 76 /** 77 * drm_client_dev_hotplug - Send hotplug event to clients 78 * @dev: DRM device 79 * 80 * This function calls the &drm_client_funcs.hotplug callback on the attached clients. 81 * 82 * drm_kms_helper_hotplug_event() calls this function, so drivers that use it 83 * don't need to call this function themselves. 84 */ 85 void drm_client_dev_hotplug(struct drm_device *dev) 86 { 87 struct drm_client_dev *client; 88 89 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 90 return; 91 92 if (!dev->mode_config.num_connector) { 93 drm_dbg_kms(dev, "No connectors found, will not send hotplug events!\n"); 94 return; 95 } 96 97 mutex_lock(&dev->clientlist_mutex); 98 list_for_each_entry(client, &dev->clientlist, list) 99 drm_client_hotplug(client); 100 mutex_unlock(&dev->clientlist_mutex); 101 } 102 EXPORT_SYMBOL(drm_client_dev_hotplug); 103 104 void drm_client_dev_restore(struct drm_device *dev) 105 { 106 struct drm_client_dev *client; 107 int ret; 108 109 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 110 return; 111 112 mutex_lock(&dev->clientlist_mutex); 113 list_for_each_entry(client, &dev->clientlist, list) { 114 if (!client->funcs || !client->funcs->restore) 115 continue; 116 117 ret = client->funcs->restore(client); 118 drm_dbg_kms(dev, "%s: ret=%d\n", client->name, ret); 119 if (!ret) /* The first one to return zero gets the privilege to restore */ 120 break; 121 } 122 mutex_unlock(&dev->clientlist_mutex); 123 } 124 125 static int drm_client_suspend(struct drm_client_dev *client, bool holds_console_lock) 126 { 127 struct drm_device *dev = client->dev; 128 int ret = 0; 129 130 if (drm_WARN_ON_ONCE(dev, client->suspended)) 131 return 0; 132 133 if (client->funcs && client->funcs->suspend) 134 ret = client->funcs->suspend(client, holds_console_lock); 135 drm_dbg_kms(dev, "%s: ret=%d\n", client->name, ret); 136 137 client->suspended = true; 138 139 return ret; 140 } 141 142 void drm_client_dev_suspend(struct drm_device *dev, bool holds_console_lock) 143 { 144 struct drm_client_dev *client; 145 146 mutex_lock(&dev->clientlist_mutex); 147 list_for_each_entry(client, &dev->clientlist, list) { 148 if (!client->suspended) 149 drm_client_suspend(client, holds_console_lock); 150 } 151 mutex_unlock(&dev->clientlist_mutex); 152 } 153 EXPORT_SYMBOL(drm_client_dev_suspend); 154 155 static int drm_client_resume(struct drm_client_dev *client, bool holds_console_lock) 156 { 157 struct drm_device *dev = client->dev; 158 int ret = 0; 159 160 if (drm_WARN_ON_ONCE(dev, !client->suspended)) 161 return 0; 162 163 if (client->funcs && client->funcs->resume) 164 ret = client->funcs->resume(client, holds_console_lock); 165 drm_dbg_kms(dev, "%s: ret=%d\n", client->name, ret); 166 167 client->suspended = false; 168 169 if (client->hotplug_pending) 170 drm_client_hotplug(client); 171 172 return ret; 173 } 174 175 void drm_client_dev_resume(struct drm_device *dev, bool holds_console_lock) 176 { 177 struct drm_client_dev *client; 178 179 mutex_lock(&dev->clientlist_mutex); 180 list_for_each_entry(client, &dev->clientlist, list) { 181 if (client->suspended) 182 drm_client_resume(client, holds_console_lock); 183 } 184 mutex_unlock(&dev->clientlist_mutex); 185 } 186 EXPORT_SYMBOL(drm_client_dev_resume); 187 188 #ifdef CONFIG_DEBUG_FS 189 static int drm_client_debugfs_internal_clients(struct seq_file *m, void *data) 190 { 191 struct drm_debugfs_entry *entry = m->private; 192 struct drm_device *dev = entry->dev; 193 struct drm_printer p = drm_seq_file_printer(m); 194 struct drm_client_dev *client; 195 196 mutex_lock(&dev->clientlist_mutex); 197 list_for_each_entry(client, &dev->clientlist, list) 198 drm_printf(&p, "%s\n", client->name); 199 mutex_unlock(&dev->clientlist_mutex); 200 201 return 0; 202 } 203 204 static const struct drm_debugfs_info drm_client_debugfs_list[] = { 205 { "internal_clients", drm_client_debugfs_internal_clients, 0 }, 206 }; 207 208 void drm_client_debugfs_init(struct drm_device *dev) 209 { 210 drm_debugfs_add_files(dev, drm_client_debugfs_list, 211 ARRAY_SIZE(drm_client_debugfs_list)); 212 } 213 #endif 214