drm_client.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499
  1. // SPDX-License-Identifier: GPL-2.0 or MIT
  2. /*
  3. * Copyright 2018 Noralf Trønnes
  4. */
  5. #include <linux/list.h>
  6. #include <linux/module.h>
  7. #include <linux/mutex.h>
  8. #include <linux/seq_file.h>
  9. #include <linux/slab.h>
  10. #include <drm/drm_client.h>
  11. #include <drm/drm_debugfs.h>
  12. #include <drm/drm_device.h>
  13. #include <drm/drm_drv.h>
  14. #include <drm/drm_file.h>
  15. #include <drm/drm_fourcc.h>
  16. #include <drm/drm_framebuffer.h>
  17. #include <drm/drm_gem.h>
  18. #include <drm/drm_mode.h>
  19. #include <drm/drm_print.h>
  20. #include "drm_crtc_internal.h"
  21. #include "drm_internal.h"
  22. /**
  23. * DOC: overview
  24. *
  25. * This library provides support for clients running in the kernel like fbdev and bootsplash.
  26. *
  27. * GEM drivers which provide a GEM based dumb buffer with a virtual address are supported.
  28. */
  29. static int drm_client_open(struct drm_client_dev *client)
  30. {
  31. struct drm_device *dev = client->dev;
  32. struct drm_file *file;
  33. file = drm_file_alloc(dev->primary);
  34. if (IS_ERR(file))
  35. return PTR_ERR(file);
  36. mutex_lock(&dev->filelist_mutex);
  37. list_add(&file->lhead, &dev->filelist_internal);
  38. mutex_unlock(&dev->filelist_mutex);
  39. client->file = file;
  40. return 0;
  41. }
  42. static void drm_client_close(struct drm_client_dev *client)
  43. {
  44. struct drm_device *dev = client->dev;
  45. mutex_lock(&dev->filelist_mutex);
  46. list_del(&client->file->lhead);
  47. mutex_unlock(&dev->filelist_mutex);
  48. drm_file_free(client->file);
  49. }
  50. /**
  51. * drm_client_init - Initialise a DRM client
  52. * @dev: DRM device
  53. * @client: DRM client
  54. * @name: Client name
  55. * @funcs: DRM client functions (optional)
  56. *
  57. * This initialises the client and opens a &drm_file.
  58. * Use drm_client_register() to complete the process.
  59. * The caller needs to hold a reference on @dev before calling this function.
  60. * The client is freed when the &drm_device is unregistered. See drm_client_release().
  61. *
  62. * Returns:
  63. * Zero on success or negative error code on failure.
  64. */
  65. int drm_client_init(struct drm_device *dev, struct drm_client_dev *client,
  66. const char *name, const struct drm_client_funcs *funcs)
  67. {
  68. int ret;
  69. if (!drm_core_check_feature(dev, DRIVER_MODESET) || !dev->driver->dumb_create)
  70. return -EOPNOTSUPP;
  71. if (funcs && !try_module_get(funcs->owner))
  72. return -ENODEV;
  73. client->dev = dev;
  74. client->name = name;
  75. client->funcs = funcs;
  76. ret = drm_client_modeset_create(client);
  77. if (ret)
  78. goto err_put_module;
  79. ret = drm_client_open(client);
  80. if (ret)
  81. goto err_free;
  82. drm_dev_get(dev);
  83. return 0;
  84. err_free:
  85. drm_client_modeset_free(client);
  86. err_put_module:
  87. if (funcs)
  88. module_put(funcs->owner);
  89. return ret;
  90. }
  91. EXPORT_SYMBOL(drm_client_init);
  92. /**
  93. * drm_client_register - Register client
  94. * @client: DRM client
  95. *
  96. * Add the client to the &drm_device client list to activate its callbacks.
  97. * @client must be initialized by a call to drm_client_init(). After
  98. * drm_client_register() it is no longer permissible to call drm_client_release()
  99. * directly (outside the unregister callback), instead cleanup will happen
  100. * automatically on driver unload.
  101. */
  102. void drm_client_register(struct drm_client_dev *client)
  103. {
  104. struct drm_device *dev = client->dev;
  105. mutex_lock(&dev->clientlist_mutex);
  106. list_add(&client->list, &dev->clientlist);
  107. mutex_unlock(&dev->clientlist_mutex);
  108. }
  109. EXPORT_SYMBOL(drm_client_register);
  110. /**
  111. * drm_client_release - Release DRM client resources
  112. * @client: DRM client
  113. *
  114. * Releases resources by closing the &drm_file that was opened by drm_client_init().
  115. * It is called automatically if the &drm_client_funcs.unregister callback is _not_ set.
  116. *
  117. * This function should only be called from the unregister callback. An exception
  118. * is fbdev which cannot free the buffer if userspace has open file descriptors.
  119. *
  120. * Note:
  121. * Clients cannot initiate a release by themselves. This is done to keep the code simple.
  122. * The driver has to be unloaded before the client can be unloaded.
  123. */
  124. void drm_client_release(struct drm_client_dev *client)
  125. {
  126. struct drm_device *dev = client->dev;
  127. drm_dbg_kms(dev, "%s\n", client->name);
  128. drm_client_modeset_free(client);
  129. drm_client_close(client);
  130. drm_dev_put(dev);
  131. if (client->funcs)
  132. module_put(client->funcs->owner);
  133. }
  134. EXPORT_SYMBOL(drm_client_release);
  135. void drm_client_dev_unregister(struct drm_device *dev)
  136. {
  137. struct drm_client_dev *client, *tmp;
  138. if (!drm_core_check_feature(dev, DRIVER_MODESET))
  139. return;
  140. mutex_lock(&dev->clientlist_mutex);
  141. list_for_each_entry_safe(client, tmp, &dev->clientlist, list) {
  142. list_del(&client->list);
  143. if (client->funcs && client->funcs->unregister) {
  144. client->funcs->unregister(client);
  145. } else {
  146. drm_client_release(client);
  147. kfree(client);
  148. }
  149. }
  150. mutex_unlock(&dev->clientlist_mutex);
  151. }
  152. /**
  153. * drm_client_dev_hotplug - Send hotplug event to clients
  154. * @dev: DRM device
  155. *
  156. * This function calls the &drm_client_funcs.hotplug callback on the attached clients.
  157. *
  158. * drm_kms_helper_hotplug_event() calls this function, so drivers that use it
  159. * don't need to call this function themselves.
  160. */
  161. void drm_client_dev_hotplug(struct drm_device *dev)
  162. {
  163. struct drm_client_dev *client;
  164. int ret;
  165. if (!drm_core_check_feature(dev, DRIVER_MODESET))
  166. return;
  167. mutex_lock(&dev->clientlist_mutex);
  168. list_for_each_entry(client, &dev->clientlist, list) {
  169. if (!client->funcs || !client->funcs->hotplug)
  170. continue;
  171. ret = client->funcs->hotplug(client);
  172. drm_dbg_kms(dev, "%s: ret=%d\n", client->name, ret);
  173. }
  174. mutex_unlock(&dev->clientlist_mutex);
  175. }
  176. EXPORT_SYMBOL(drm_client_dev_hotplug);
  177. void drm_client_dev_restore(struct drm_device *dev)
  178. {
  179. struct drm_client_dev *client;
  180. int ret;
  181. if (!drm_core_check_feature(dev, DRIVER_MODESET))
  182. return;
  183. mutex_lock(&dev->clientlist_mutex);
  184. list_for_each_entry(client, &dev->clientlist, list) {
  185. if (!client->funcs || !client->funcs->restore)
  186. continue;
  187. ret = client->funcs->restore(client);
  188. drm_dbg_kms(dev, "%s: ret=%d\n", client->name, ret);
  189. if (!ret) /* The first one to return zero gets the privilege to restore */
  190. break;
  191. }
  192. mutex_unlock(&dev->clientlist_mutex);
  193. }
  194. static void drm_client_buffer_delete(struct drm_client_buffer *buffer)
  195. {
  196. struct drm_device *dev = buffer->client->dev;
  197. drm_gem_vunmap(buffer->gem, buffer->vaddr);
  198. if (buffer->gem)
  199. drm_gem_object_put(buffer->gem);
  200. if (buffer->handle)
  201. drm_mode_destroy_dumb(dev, buffer->handle, buffer->client->file);
  202. kfree(buffer);
  203. }
  204. static struct drm_client_buffer *
  205. drm_client_buffer_create(struct drm_client_dev *client, u32 width, u32 height, u32 format)
  206. {
  207. const struct drm_format_info *info = drm_format_info(format);
  208. struct drm_mode_create_dumb dumb_args = { };
  209. struct drm_device *dev = client->dev;
  210. struct drm_client_buffer *buffer;
  211. struct drm_gem_object *obj;
  212. int ret;
  213. buffer = kzalloc(sizeof(*buffer), GFP_KERNEL);
  214. if (!buffer)
  215. return ERR_PTR(-ENOMEM);
  216. buffer->client = client;
  217. dumb_args.width = width;
  218. dumb_args.height = height;
  219. dumb_args.bpp = info->cpp[0] * 8;
  220. ret = drm_mode_create_dumb(dev, &dumb_args, client->file);
  221. if (ret)
  222. goto err_delete;
  223. buffer->handle = dumb_args.handle;
  224. buffer->pitch = dumb_args.pitch;
  225. obj = drm_gem_object_lookup(client->file, dumb_args.handle);
  226. if (!obj) {
  227. ret = -ENOENT;
  228. goto err_delete;
  229. }
  230. buffer->gem = obj;
  231. return buffer;
  232. err_delete:
  233. drm_client_buffer_delete(buffer);
  234. return ERR_PTR(ret);
  235. }
  236. /**
  237. * drm_client_buffer_vmap - Map DRM client buffer into address space
  238. * @buffer: DRM client buffer
  239. *
  240. * This function maps a client buffer into kernel address space. If the
  241. * buffer is already mapped, it returns the mapping's address.
  242. *
  243. * Client buffer mappings are not ref'counted. Each call to
  244. * drm_client_buffer_vmap() should be followed by a call to
  245. * drm_client_buffer_vunmap(); or the client buffer should be mapped
  246. * throughout its lifetime.
  247. *
  248. * Returns:
  249. * The mapped memory's address
  250. */
  251. void *drm_client_buffer_vmap(struct drm_client_buffer *buffer)
  252. {
  253. void *vaddr;
  254. if (buffer->vaddr)
  255. return buffer->vaddr;
  256. /*
  257. * FIXME: The dependency on GEM here isn't required, we could
  258. * convert the driver handle to a dma-buf instead and use the
  259. * backend-agnostic dma-buf vmap support instead. This would
  260. * require that the handle2fd prime ioctl is reworked to pull the
  261. * fd_install step out of the driver backend hooks, to make that
  262. * final step optional for internal users.
  263. */
  264. vaddr = drm_gem_vmap(buffer->gem);
  265. if (IS_ERR(vaddr))
  266. return vaddr;
  267. buffer->vaddr = vaddr;
  268. return vaddr;
  269. }
  270. EXPORT_SYMBOL(drm_client_buffer_vmap);
  271. /**
  272. * drm_client_buffer_vunmap - Unmap DRM client buffer
  273. * @buffer: DRM client buffer
  274. *
  275. * This function removes a client buffer's memory mapping. Calling this
  276. * function is only required by clients that manage their buffer mappings
  277. * by themselves.
  278. */
  279. void drm_client_buffer_vunmap(struct drm_client_buffer *buffer)
  280. {
  281. drm_gem_vunmap(buffer->gem, buffer->vaddr);
  282. buffer->vaddr = NULL;
  283. }
  284. EXPORT_SYMBOL(drm_client_buffer_vunmap);
  285. static void drm_client_buffer_rmfb(struct drm_client_buffer *buffer)
  286. {
  287. int ret;
  288. if (!buffer->fb)
  289. return;
  290. ret = drm_mode_rmfb(buffer->client->dev, buffer->fb->base.id, buffer->client->file);
  291. if (ret)
  292. drm_err(buffer->client->dev,
  293. "Error removing FB:%u (%d)\n", buffer->fb->base.id, ret);
  294. buffer->fb = NULL;
  295. }
  296. static int drm_client_buffer_addfb(struct drm_client_buffer *buffer,
  297. u32 width, u32 height, u32 format)
  298. {
  299. struct drm_client_dev *client = buffer->client;
  300. struct drm_mode_fb_cmd fb_req = { };
  301. const struct drm_format_info *info;
  302. int ret;
  303. info = drm_format_info(format);
  304. fb_req.bpp = info->cpp[0] * 8;
  305. fb_req.depth = info->depth;
  306. fb_req.width = width;
  307. fb_req.height = height;
  308. fb_req.handle = buffer->handle;
  309. fb_req.pitch = buffer->pitch;
  310. ret = drm_mode_addfb(client->dev, &fb_req, client->file);
  311. if (ret)
  312. return ret;
  313. buffer->fb = drm_framebuffer_lookup(client->dev, buffer->client->file, fb_req.fb_id);
  314. if (WARN_ON(!buffer->fb))
  315. return -ENOENT;
  316. /* drop the reference we picked up in framebuffer lookup */
  317. drm_framebuffer_put(buffer->fb);
  318. strscpy(buffer->fb->comm, client->name, TASK_COMM_LEN);
  319. return 0;
  320. }
  321. /**
  322. * drm_client_framebuffer_create - Create a client framebuffer
  323. * @client: DRM client
  324. * @width: Framebuffer width
  325. * @height: Framebuffer height
  326. * @format: Buffer format
  327. *
  328. * This function creates a &drm_client_buffer which consists of a
  329. * &drm_framebuffer backed by a dumb buffer.
  330. * Call drm_client_framebuffer_delete() to free the buffer.
  331. *
  332. * Returns:
  333. * Pointer to a client buffer or an error pointer on failure.
  334. */
  335. struct drm_client_buffer *
  336. drm_client_framebuffer_create(struct drm_client_dev *client, u32 width, u32 height, u32 format)
  337. {
  338. struct drm_client_buffer *buffer;
  339. int ret;
  340. buffer = drm_client_buffer_create(client, width, height, format);
  341. if (IS_ERR(buffer))
  342. return buffer;
  343. ret = drm_client_buffer_addfb(buffer, width, height, format);
  344. if (ret) {
  345. drm_client_buffer_delete(buffer);
  346. return ERR_PTR(ret);
  347. }
  348. return buffer;
  349. }
  350. EXPORT_SYMBOL(drm_client_framebuffer_create);
  351. /**
  352. * drm_client_framebuffer_delete - Delete a client framebuffer
  353. * @buffer: DRM client buffer (can be NULL)
  354. */
  355. void drm_client_framebuffer_delete(struct drm_client_buffer *buffer)
  356. {
  357. if (!buffer)
  358. return;
  359. drm_client_buffer_rmfb(buffer);
  360. drm_client_buffer_delete(buffer);
  361. }
  362. EXPORT_SYMBOL(drm_client_framebuffer_delete);
  363. /**
  364. * drm_client_framebuffer_flush - Manually flush client framebuffer
  365. * @buffer: DRM client buffer (can be NULL)
  366. * @rect: Damage rectangle (if NULL flushes all)
  367. *
  368. * This calls &drm_framebuffer_funcs->dirty (if present) to flush buffer changes
  369. * for drivers that need it.
  370. *
  371. * Returns:
  372. * Zero on success or negative error code on failure.
  373. */
  374. int drm_client_framebuffer_flush(struct drm_client_buffer *buffer, struct drm_rect *rect)
  375. {
  376. if (!buffer || !buffer->fb || !buffer->fb->funcs->dirty)
  377. return 0;
  378. if (rect) {
  379. struct drm_clip_rect clip = {
  380. .x1 = rect->x1,
  381. .y1 = rect->y1,
  382. .x2 = rect->x2,
  383. .y2 = rect->y2,
  384. };
  385. return buffer->fb->funcs->dirty(buffer->fb, buffer->client->file,
  386. 0, 0, &clip, 1);
  387. }
  388. return buffer->fb->funcs->dirty(buffer->fb, buffer->client->file,
  389. 0, 0, NULL, 0);
  390. }
  391. EXPORT_SYMBOL(drm_client_framebuffer_flush);
  392. #ifdef CONFIG_DEBUG_FS
  393. static int drm_client_debugfs_internal_clients(struct seq_file *m, void *data)
  394. {
  395. struct drm_info_node *node = m->private;
  396. struct drm_device *dev = node->minor->dev;
  397. struct drm_printer p = drm_seq_file_printer(m);
  398. struct drm_client_dev *client;
  399. mutex_lock(&dev->clientlist_mutex);
  400. list_for_each_entry(client, &dev->clientlist, list)
  401. drm_printf(&p, "%s\n", client->name);
  402. mutex_unlock(&dev->clientlist_mutex);
  403. return 0;
  404. }
  405. static const struct drm_info_list drm_client_debugfs_list[] = {
  406. { "internal_clients", drm_client_debugfs_internal_clients, 0 },
  407. };
  408. void drm_client_debugfs_init(struct drm_minor *minor)
  409. {
  410. drm_debugfs_create_files(drm_client_debugfs_list,
  411. ARRAY_SIZE(drm_client_debugfs_list),
  412. minor->debugfs_root, minor);
  413. }
  414. #endif