1
2
3
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
29
30
31
32
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
66
67
68
69
70
71
72
73
74
75
76
77
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
118
119
120
121
122
123
124
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
138
139
140
141
142
143
144
145
146
147
148
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
186
187
188
189
190
191
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)
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
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
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
319
320
321
322
323
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
337
338
339
340
341
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
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
400
401
402
403
404
405
406
407
408
409
410
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
434
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
448
449
450
451
452
453
454
455
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
506