Loading...
Note: File does not exist in v4.6.
1// SPDX-License-Identifier: GPL-2.0 OR MIT
2
3/*
4 * Xen para-virtual DRM device
5 *
6 * Copyright (C) 2016-2018 EPAM Systems Inc.
7 *
8 * Author: Oleksandr Andrushchenko <oleksandr_andrushchenko@epam.com>
9 */
10
11#include <linux/delay.h>
12#include <linux/dma-mapping.h>
13#include <linux/module.h>
14#include <linux/of_device.h>
15
16#include <drm/drm_atomic_helper.h>
17#include <drm/drm_drv.h>
18#include <drm/drm_ioctl.h>
19#include <drm/drm_probe_helper.h>
20#include <drm/drm_file.h>
21#include <drm/drm_gem.h>
22
23#include <xen/platform_pci.h>
24#include <xen/xen.h>
25#include <xen/xenbus.h>
26
27#include <xen/xen-front-pgdir-shbuf.h>
28#include <xen/interface/io/displif.h>
29
30#include "xen_drm_front.h"
31#include "xen_drm_front_cfg.h"
32#include "xen_drm_front_evtchnl.h"
33#include "xen_drm_front_gem.h"
34#include "xen_drm_front_kms.h"
35
36struct xen_drm_front_dbuf {
37 struct list_head list;
38 u64 dbuf_cookie;
39 u64 fb_cookie;
40
41 struct xen_front_pgdir_shbuf shbuf;
42};
43
44static void dbuf_add_to_list(struct xen_drm_front_info *front_info,
45 struct xen_drm_front_dbuf *dbuf, u64 dbuf_cookie)
46{
47 dbuf->dbuf_cookie = dbuf_cookie;
48 list_add(&dbuf->list, &front_info->dbuf_list);
49}
50
51static struct xen_drm_front_dbuf *dbuf_get(struct list_head *dbuf_list,
52 u64 dbuf_cookie)
53{
54 struct xen_drm_front_dbuf *buf, *q;
55
56 list_for_each_entry_safe(buf, q, dbuf_list, list)
57 if (buf->dbuf_cookie == dbuf_cookie)
58 return buf;
59
60 return NULL;
61}
62
63static void dbuf_free(struct list_head *dbuf_list, u64 dbuf_cookie)
64{
65 struct xen_drm_front_dbuf *buf, *q;
66
67 list_for_each_entry_safe(buf, q, dbuf_list, list)
68 if (buf->dbuf_cookie == dbuf_cookie) {
69 list_del(&buf->list);
70 xen_front_pgdir_shbuf_unmap(&buf->shbuf);
71 xen_front_pgdir_shbuf_free(&buf->shbuf);
72 kfree(buf);
73 break;
74 }
75}
76
77static void dbuf_free_all(struct list_head *dbuf_list)
78{
79 struct xen_drm_front_dbuf *buf, *q;
80
81 list_for_each_entry_safe(buf, q, dbuf_list, list) {
82 list_del(&buf->list);
83 xen_front_pgdir_shbuf_unmap(&buf->shbuf);
84 xen_front_pgdir_shbuf_free(&buf->shbuf);
85 kfree(buf);
86 }
87}
88
89static struct xendispl_req *
90be_prepare_req(struct xen_drm_front_evtchnl *evtchnl, u8 operation)
91{
92 struct xendispl_req *req;
93
94 req = RING_GET_REQUEST(&evtchnl->u.req.ring,
95 evtchnl->u.req.ring.req_prod_pvt);
96 req->operation = operation;
97 req->id = evtchnl->evt_next_id++;
98 evtchnl->evt_id = req->id;
99 return req;
100}
101
102static int be_stream_do_io(struct xen_drm_front_evtchnl *evtchnl,
103 struct xendispl_req *req)
104{
105 reinit_completion(&evtchnl->u.req.completion);
106 if (unlikely(evtchnl->state != EVTCHNL_STATE_CONNECTED))
107 return -EIO;
108
109 xen_drm_front_evtchnl_flush(evtchnl);
110 return 0;
111}
112
113static int be_stream_wait_io(struct xen_drm_front_evtchnl *evtchnl)
114{
115 if (wait_for_completion_timeout(&evtchnl->u.req.completion,
116 msecs_to_jiffies(XEN_DRM_FRONT_WAIT_BACK_MS)) <= 0)
117 return -ETIMEDOUT;
118
119 return evtchnl->u.req.resp_status;
120}
121
122int xen_drm_front_mode_set(struct xen_drm_front_drm_pipeline *pipeline,
123 u32 x, u32 y, u32 width, u32 height,
124 u32 bpp, u64 fb_cookie)
125{
126 struct xen_drm_front_evtchnl *evtchnl;
127 struct xen_drm_front_info *front_info;
128 struct xendispl_req *req;
129 unsigned long flags;
130 int ret;
131
132 front_info = pipeline->drm_info->front_info;
133 evtchnl = &front_info->evt_pairs[pipeline->index].req;
134 if (unlikely(!evtchnl))
135 return -EIO;
136
137 mutex_lock(&evtchnl->u.req.req_io_lock);
138
139 spin_lock_irqsave(&front_info->io_lock, flags);
140 req = be_prepare_req(evtchnl, XENDISPL_OP_SET_CONFIG);
141 req->op.set_config.x = x;
142 req->op.set_config.y = y;
143 req->op.set_config.width = width;
144 req->op.set_config.height = height;
145 req->op.set_config.bpp = bpp;
146 req->op.set_config.fb_cookie = fb_cookie;
147
148 ret = be_stream_do_io(evtchnl, req);
149 spin_unlock_irqrestore(&front_info->io_lock, flags);
150
151 if (ret == 0)
152 ret = be_stream_wait_io(evtchnl);
153
154 mutex_unlock(&evtchnl->u.req.req_io_lock);
155 return ret;
156}
157
158int xen_drm_front_dbuf_create(struct xen_drm_front_info *front_info,
159 u64 dbuf_cookie, u32 width, u32 height,
160 u32 bpp, u64 size, struct page **pages)
161{
162 struct xen_drm_front_evtchnl *evtchnl;
163 struct xen_drm_front_dbuf *dbuf;
164 struct xendispl_req *req;
165 struct xen_front_pgdir_shbuf_cfg buf_cfg;
166 unsigned long flags;
167 int ret;
168
169 evtchnl = &front_info->evt_pairs[GENERIC_OP_EVT_CHNL].req;
170 if (unlikely(!evtchnl))
171 return -EIO;
172
173 dbuf = kzalloc(sizeof(*dbuf), GFP_KERNEL);
174 if (!dbuf)
175 return -ENOMEM;
176
177 dbuf_add_to_list(front_info, dbuf, dbuf_cookie);
178
179 memset(&buf_cfg, 0, sizeof(buf_cfg));
180 buf_cfg.xb_dev = front_info->xb_dev;
181 buf_cfg.num_pages = DIV_ROUND_UP(size, PAGE_SIZE);
182 buf_cfg.pages = pages;
183 buf_cfg.pgdir = &dbuf->shbuf;
184 buf_cfg.be_alloc = front_info->cfg.be_alloc;
185
186 ret = xen_front_pgdir_shbuf_alloc(&buf_cfg);
187 if (ret < 0)
188 goto fail_shbuf_alloc;
189
190 mutex_lock(&evtchnl->u.req.req_io_lock);
191
192 spin_lock_irqsave(&front_info->io_lock, flags);
193 req = be_prepare_req(evtchnl, XENDISPL_OP_DBUF_CREATE);
194 req->op.dbuf_create.gref_directory =
195 xen_front_pgdir_shbuf_get_dir_start(&dbuf->shbuf);
196 req->op.dbuf_create.buffer_sz = size;
197 req->op.dbuf_create.dbuf_cookie = dbuf_cookie;
198 req->op.dbuf_create.width = width;
199 req->op.dbuf_create.height = height;
200 req->op.dbuf_create.bpp = bpp;
201 if (buf_cfg.be_alloc)
202 req->op.dbuf_create.flags |= XENDISPL_DBUF_FLG_REQ_ALLOC;
203
204 ret = be_stream_do_io(evtchnl, req);
205 spin_unlock_irqrestore(&front_info->io_lock, flags);
206
207 if (ret < 0)
208 goto fail;
209
210 ret = be_stream_wait_io(evtchnl);
211 if (ret < 0)
212 goto fail;
213
214 ret = xen_front_pgdir_shbuf_map(&dbuf->shbuf);
215 if (ret < 0)
216 goto fail;
217
218 mutex_unlock(&evtchnl->u.req.req_io_lock);
219 return 0;
220
221fail:
222 mutex_unlock(&evtchnl->u.req.req_io_lock);
223fail_shbuf_alloc:
224 dbuf_free(&front_info->dbuf_list, dbuf_cookie);
225 return ret;
226}
227
228static int xen_drm_front_dbuf_destroy(struct xen_drm_front_info *front_info,
229 u64 dbuf_cookie)
230{
231 struct xen_drm_front_evtchnl *evtchnl;
232 struct xendispl_req *req;
233 unsigned long flags;
234 bool be_alloc;
235 int ret;
236
237 evtchnl = &front_info->evt_pairs[GENERIC_OP_EVT_CHNL].req;
238 if (unlikely(!evtchnl))
239 return -EIO;
240
241 be_alloc = front_info->cfg.be_alloc;
242
243 /*
244 * For the backend allocated buffer release references now, so backend
245 * can free the buffer.
246 */
247 if (be_alloc)
248 dbuf_free(&front_info->dbuf_list, dbuf_cookie);
249
250 mutex_lock(&evtchnl->u.req.req_io_lock);
251
252 spin_lock_irqsave(&front_info->io_lock, flags);
253 req = be_prepare_req(evtchnl, XENDISPL_OP_DBUF_DESTROY);
254 req->op.dbuf_destroy.dbuf_cookie = dbuf_cookie;
255
256 ret = be_stream_do_io(evtchnl, req);
257 spin_unlock_irqrestore(&front_info->io_lock, flags);
258
259 if (ret == 0)
260 ret = be_stream_wait_io(evtchnl);
261
262 /*
263 * Do this regardless of communication status with the backend:
264 * if we cannot remove remote resources remove what we can locally.
265 */
266 if (!be_alloc)
267 dbuf_free(&front_info->dbuf_list, dbuf_cookie);
268
269 mutex_unlock(&evtchnl->u.req.req_io_lock);
270 return ret;
271}
272
273int xen_drm_front_fb_attach(struct xen_drm_front_info *front_info,
274 u64 dbuf_cookie, u64 fb_cookie, u32 width,
275 u32 height, u32 pixel_format)
276{
277 struct xen_drm_front_evtchnl *evtchnl;
278 struct xen_drm_front_dbuf *buf;
279 struct xendispl_req *req;
280 unsigned long flags;
281 int ret;
282
283 evtchnl = &front_info->evt_pairs[GENERIC_OP_EVT_CHNL].req;
284 if (unlikely(!evtchnl))
285 return -EIO;
286
287 buf = dbuf_get(&front_info->dbuf_list, dbuf_cookie);
288 if (!buf)
289 return -EINVAL;
290
291 buf->fb_cookie = fb_cookie;
292
293 mutex_lock(&evtchnl->u.req.req_io_lock);
294
295 spin_lock_irqsave(&front_info->io_lock, flags);
296 req = be_prepare_req(evtchnl, XENDISPL_OP_FB_ATTACH);
297 req->op.fb_attach.dbuf_cookie = dbuf_cookie;
298 req->op.fb_attach.fb_cookie = fb_cookie;
299 req->op.fb_attach.width = width;
300 req->op.fb_attach.height = height;
301 req->op.fb_attach.pixel_format = pixel_format;
302
303 ret = be_stream_do_io(evtchnl, req);
304 spin_unlock_irqrestore(&front_info->io_lock, flags);
305
306 if (ret == 0)
307 ret = be_stream_wait_io(evtchnl);
308
309 mutex_unlock(&evtchnl->u.req.req_io_lock);
310 return ret;
311}
312
313int xen_drm_front_fb_detach(struct xen_drm_front_info *front_info,
314 u64 fb_cookie)
315{
316 struct xen_drm_front_evtchnl *evtchnl;
317 struct xendispl_req *req;
318 unsigned long flags;
319 int ret;
320
321 evtchnl = &front_info->evt_pairs[GENERIC_OP_EVT_CHNL].req;
322 if (unlikely(!evtchnl))
323 return -EIO;
324
325 mutex_lock(&evtchnl->u.req.req_io_lock);
326
327 spin_lock_irqsave(&front_info->io_lock, flags);
328 req = be_prepare_req(evtchnl, XENDISPL_OP_FB_DETACH);
329 req->op.fb_detach.fb_cookie = fb_cookie;
330
331 ret = be_stream_do_io(evtchnl, req);
332 spin_unlock_irqrestore(&front_info->io_lock, flags);
333
334 if (ret == 0)
335 ret = be_stream_wait_io(evtchnl);
336
337 mutex_unlock(&evtchnl->u.req.req_io_lock);
338 return ret;
339}
340
341int xen_drm_front_page_flip(struct xen_drm_front_info *front_info,
342 int conn_idx, u64 fb_cookie)
343{
344 struct xen_drm_front_evtchnl *evtchnl;
345 struct xendispl_req *req;
346 unsigned long flags;
347 int ret;
348
349 if (unlikely(conn_idx >= front_info->num_evt_pairs))
350 return -EINVAL;
351
352 evtchnl = &front_info->evt_pairs[conn_idx].req;
353
354 mutex_lock(&evtchnl->u.req.req_io_lock);
355
356 spin_lock_irqsave(&front_info->io_lock, flags);
357 req = be_prepare_req(evtchnl, XENDISPL_OP_PG_FLIP);
358 req->op.pg_flip.fb_cookie = fb_cookie;
359
360 ret = be_stream_do_io(evtchnl, req);
361 spin_unlock_irqrestore(&front_info->io_lock, flags);
362
363 if (ret == 0)
364 ret = be_stream_wait_io(evtchnl);
365
366 mutex_unlock(&evtchnl->u.req.req_io_lock);
367 return ret;
368}
369
370void xen_drm_front_on_frame_done(struct xen_drm_front_info *front_info,
371 int conn_idx, u64 fb_cookie)
372{
373 struct xen_drm_front_drm_info *drm_info = front_info->drm_info;
374
375 if (unlikely(conn_idx >= front_info->cfg.num_connectors))
376 return;
377
378 xen_drm_front_kms_on_frame_done(&drm_info->pipeline[conn_idx],
379 fb_cookie);
380}
381
382static int xen_drm_drv_dumb_create(struct drm_file *filp,
383 struct drm_device *dev,
384 struct drm_mode_create_dumb *args)
385{
386 struct xen_drm_front_drm_info *drm_info = dev->dev_private;
387 struct drm_gem_object *obj;
388 int ret;
389
390 /*
391 * Dumb creation is a two stage process: first we create a fully
392 * constructed GEM object which is communicated to the backend, and
393 * only after that we can create GEM's handle. This is done so,
394 * because of the possible races: once you create a handle it becomes
395 * immediately visible to user-space, so the latter can try accessing
396 * object without pages etc.
397 * For details also see drm_gem_handle_create
398 */
399 args->pitch = DIV_ROUND_UP(args->width * args->bpp, 8);
400 args->size = args->pitch * args->height;
401
402 obj = xen_drm_front_gem_create(dev, args->size);
403 if (IS_ERR_OR_NULL(obj)) {
404 ret = PTR_ERR(obj);
405 goto fail;
406 }
407
408 ret = xen_drm_front_dbuf_create(drm_info->front_info,
409 xen_drm_front_dbuf_to_cookie(obj),
410 args->width, args->height, args->bpp,
411 args->size,
412 xen_drm_front_gem_get_pages(obj));
413 if (ret)
414 goto fail_backend;
415
416 /* This is the tail of GEM object creation */
417 ret = drm_gem_handle_create(filp, obj, &args->handle);
418 if (ret)
419 goto fail_handle;
420
421 /* Drop reference from allocate - handle holds it now */
422 drm_gem_object_put_unlocked(obj);
423 return 0;
424
425fail_handle:
426 xen_drm_front_dbuf_destroy(drm_info->front_info,
427 xen_drm_front_dbuf_to_cookie(obj));
428fail_backend:
429 /* drop reference from allocate */
430 drm_gem_object_put_unlocked(obj);
431fail:
432 DRM_ERROR("Failed to create dumb buffer: %d\n", ret);
433 return ret;
434}
435
436static void xen_drm_drv_free_object_unlocked(struct drm_gem_object *obj)
437{
438 struct xen_drm_front_drm_info *drm_info = obj->dev->dev_private;
439 int idx;
440
441 if (drm_dev_enter(obj->dev, &idx)) {
442 xen_drm_front_dbuf_destroy(drm_info->front_info,
443 xen_drm_front_dbuf_to_cookie(obj));
444 drm_dev_exit(idx);
445 } else {
446 dbuf_free(&drm_info->front_info->dbuf_list,
447 xen_drm_front_dbuf_to_cookie(obj));
448 }
449
450 xen_drm_front_gem_free_object_unlocked(obj);
451}
452
453static void xen_drm_drv_release(struct drm_device *dev)
454{
455 struct xen_drm_front_drm_info *drm_info = dev->dev_private;
456 struct xen_drm_front_info *front_info = drm_info->front_info;
457
458 xen_drm_front_kms_fini(drm_info);
459
460 drm_atomic_helper_shutdown(dev);
461 drm_mode_config_cleanup(dev);
462
463 drm_dev_fini(dev);
464 kfree(dev);
465
466 if (front_info->cfg.be_alloc)
467 xenbus_switch_state(front_info->xb_dev,
468 XenbusStateInitialising);
469
470 kfree(drm_info);
471}
472
473static const struct file_operations xen_drm_dev_fops = {
474 .owner = THIS_MODULE,
475 .open = drm_open,
476 .release = drm_release,
477 .unlocked_ioctl = drm_ioctl,
478#ifdef CONFIG_COMPAT
479 .compat_ioctl = drm_compat_ioctl,
480#endif
481 .poll = drm_poll,
482 .read = drm_read,
483 .llseek = no_llseek,
484 .mmap = xen_drm_front_gem_mmap,
485};
486
487static const struct vm_operations_struct xen_drm_drv_vm_ops = {
488 .open = drm_gem_vm_open,
489 .close = drm_gem_vm_close,
490};
491
492static struct drm_driver xen_drm_driver = {
493 .driver_features = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC,
494 .release = xen_drm_drv_release,
495 .gem_vm_ops = &xen_drm_drv_vm_ops,
496 .gem_free_object_unlocked = xen_drm_drv_free_object_unlocked,
497 .prime_handle_to_fd = drm_gem_prime_handle_to_fd,
498 .prime_fd_to_handle = drm_gem_prime_fd_to_handle,
499 .gem_prime_import_sg_table = xen_drm_front_gem_import_sg_table,
500 .gem_prime_get_sg_table = xen_drm_front_gem_get_sg_table,
501 .gem_prime_vmap = xen_drm_front_gem_prime_vmap,
502 .gem_prime_vunmap = xen_drm_front_gem_prime_vunmap,
503 .gem_prime_mmap = xen_drm_front_gem_prime_mmap,
504 .dumb_create = xen_drm_drv_dumb_create,
505 .fops = &xen_drm_dev_fops,
506 .name = "xendrm-du",
507 .desc = "Xen PV DRM Display Unit",
508 .date = "20180221",
509 .major = 1,
510 .minor = 0,
511
512};
513
514static int xen_drm_drv_init(struct xen_drm_front_info *front_info)
515{
516 struct device *dev = &front_info->xb_dev->dev;
517 struct xen_drm_front_drm_info *drm_info;
518 struct drm_device *drm_dev;
519 int ret;
520
521 DRM_INFO("Creating %s\n", xen_drm_driver.desc);
522
523 drm_info = kzalloc(sizeof(*drm_info), GFP_KERNEL);
524 if (!drm_info) {
525 ret = -ENOMEM;
526 goto fail;
527 }
528
529 drm_info->front_info = front_info;
530 front_info->drm_info = drm_info;
531
532 drm_dev = drm_dev_alloc(&xen_drm_driver, dev);
533 if (IS_ERR(drm_dev)) {
534 ret = PTR_ERR(drm_dev);
535 goto fail;
536 }
537
538 drm_info->drm_dev = drm_dev;
539
540 drm_dev->dev_private = drm_info;
541
542 ret = xen_drm_front_kms_init(drm_info);
543 if (ret) {
544 DRM_ERROR("Failed to initialize DRM/KMS, ret %d\n", ret);
545 goto fail_modeset;
546 }
547
548 ret = drm_dev_register(drm_dev, 0);
549 if (ret)
550 goto fail_register;
551
552 DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n",
553 xen_drm_driver.name, xen_drm_driver.major,
554 xen_drm_driver.minor, xen_drm_driver.patchlevel,
555 xen_drm_driver.date, drm_dev->primary->index);
556
557 return 0;
558
559fail_register:
560 drm_dev_unregister(drm_dev);
561fail_modeset:
562 drm_kms_helper_poll_fini(drm_dev);
563 drm_mode_config_cleanup(drm_dev);
564fail:
565 kfree(drm_info);
566 return ret;
567}
568
569static void xen_drm_drv_fini(struct xen_drm_front_info *front_info)
570{
571 struct xen_drm_front_drm_info *drm_info = front_info->drm_info;
572 struct drm_device *dev;
573
574 if (!drm_info)
575 return;
576
577 dev = drm_info->drm_dev;
578 if (!dev)
579 return;
580
581 /* Nothing to do if device is already unplugged */
582 if (drm_dev_is_unplugged(dev))
583 return;
584
585 drm_kms_helper_poll_fini(dev);
586 drm_dev_unplug(dev);
587 drm_dev_put(dev);
588
589 front_info->drm_info = NULL;
590
591 xen_drm_front_evtchnl_free_all(front_info);
592 dbuf_free_all(&front_info->dbuf_list);
593
594 /*
595 * If we are not using backend allocated buffers, then tell the
596 * backend we are ready to (re)initialize. Otherwise, wait for
597 * drm_driver.release.
598 */
599 if (!front_info->cfg.be_alloc)
600 xenbus_switch_state(front_info->xb_dev,
601 XenbusStateInitialising);
602}
603
604static int displback_initwait(struct xen_drm_front_info *front_info)
605{
606 struct xen_drm_front_cfg *cfg = &front_info->cfg;
607 int ret;
608
609 cfg->front_info = front_info;
610 ret = xen_drm_front_cfg_card(front_info, cfg);
611 if (ret < 0)
612 return ret;
613
614 DRM_INFO("Have %d connector(s)\n", cfg->num_connectors);
615 /* Create event channels for all connectors and publish */
616 ret = xen_drm_front_evtchnl_create_all(front_info);
617 if (ret < 0)
618 return ret;
619
620 return xen_drm_front_evtchnl_publish_all(front_info);
621}
622
623static int displback_connect(struct xen_drm_front_info *front_info)
624{
625 xen_drm_front_evtchnl_set_state(front_info, EVTCHNL_STATE_CONNECTED);
626 return xen_drm_drv_init(front_info);
627}
628
629static void displback_disconnect(struct xen_drm_front_info *front_info)
630{
631 if (!front_info->drm_info)
632 return;
633
634 /* Tell the backend to wait until we release the DRM driver. */
635 xenbus_switch_state(front_info->xb_dev, XenbusStateReconfiguring);
636
637 xen_drm_drv_fini(front_info);
638}
639
640static void displback_changed(struct xenbus_device *xb_dev,
641 enum xenbus_state backend_state)
642{
643 struct xen_drm_front_info *front_info = dev_get_drvdata(&xb_dev->dev);
644 int ret;
645
646 DRM_DEBUG("Backend state is %s, front is %s\n",
647 xenbus_strstate(backend_state),
648 xenbus_strstate(xb_dev->state));
649
650 switch (backend_state) {
651 case XenbusStateReconfiguring:
652 /* fall through */
653 case XenbusStateReconfigured:
654 /* fall through */
655 case XenbusStateInitialised:
656 break;
657
658 case XenbusStateInitialising:
659 if (xb_dev->state == XenbusStateReconfiguring)
660 break;
661
662 /* recovering after backend unexpected closure */
663 displback_disconnect(front_info);
664 break;
665
666 case XenbusStateInitWait:
667 if (xb_dev->state == XenbusStateReconfiguring)
668 break;
669
670 /* recovering after backend unexpected closure */
671 displback_disconnect(front_info);
672 if (xb_dev->state != XenbusStateInitialising)
673 break;
674
675 ret = displback_initwait(front_info);
676 if (ret < 0)
677 xenbus_dev_fatal(xb_dev, ret, "initializing frontend");
678 else
679 xenbus_switch_state(xb_dev, XenbusStateInitialised);
680 break;
681
682 case XenbusStateConnected:
683 if (xb_dev->state != XenbusStateInitialised)
684 break;
685
686 ret = displback_connect(front_info);
687 if (ret < 0) {
688 displback_disconnect(front_info);
689 xenbus_dev_fatal(xb_dev, ret, "connecting backend");
690 } else {
691 xenbus_switch_state(xb_dev, XenbusStateConnected);
692 }
693 break;
694
695 case XenbusStateClosing:
696 /*
697 * in this state backend starts freeing resources,
698 * so let it go into closed state, so we can also
699 * remove ours
700 */
701 break;
702
703 case XenbusStateUnknown:
704 /* fall through */
705 case XenbusStateClosed:
706 if (xb_dev->state == XenbusStateClosed)
707 break;
708
709 displback_disconnect(front_info);
710 break;
711 }
712}
713
714static int xen_drv_probe(struct xenbus_device *xb_dev,
715 const struct xenbus_device_id *id)
716{
717 struct xen_drm_front_info *front_info;
718 struct device *dev = &xb_dev->dev;
719 int ret;
720
721 ret = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(64));
722 if (ret < 0) {
723 DRM_ERROR("Cannot setup DMA mask, ret %d", ret);
724 return ret;
725 }
726
727 front_info = devm_kzalloc(&xb_dev->dev,
728 sizeof(*front_info), GFP_KERNEL);
729 if (!front_info)
730 return -ENOMEM;
731
732 front_info->xb_dev = xb_dev;
733 spin_lock_init(&front_info->io_lock);
734 INIT_LIST_HEAD(&front_info->dbuf_list);
735 dev_set_drvdata(&xb_dev->dev, front_info);
736
737 return xenbus_switch_state(xb_dev, XenbusStateInitialising);
738}
739
740static int xen_drv_remove(struct xenbus_device *dev)
741{
742 struct xen_drm_front_info *front_info = dev_get_drvdata(&dev->dev);
743 int to = 100;
744
745 xenbus_switch_state(dev, XenbusStateClosing);
746
747 /*
748 * On driver removal it is disconnected from XenBus,
749 * so no backend state change events come via .otherend_changed
750 * callback. This prevents us from exiting gracefully, e.g.
751 * signaling the backend to free event channels, waiting for its
752 * state to change to XenbusStateClosed and cleaning at our end.
753 * Normally when front driver removed backend will finally go into
754 * XenbusStateInitWait state.
755 *
756 * Workaround: read backend's state manually and wait with time-out.
757 */
758 while ((xenbus_read_unsigned(front_info->xb_dev->otherend, "state",
759 XenbusStateUnknown) != XenbusStateInitWait) &&
760 --to)
761 msleep(10);
762
763 if (!to) {
764 unsigned int state;
765
766 state = xenbus_read_unsigned(front_info->xb_dev->otherend,
767 "state", XenbusStateUnknown);
768 DRM_ERROR("Backend state is %s while removing driver\n",
769 xenbus_strstate(state));
770 }
771
772 xen_drm_drv_fini(front_info);
773 xenbus_frontend_closed(dev);
774 return 0;
775}
776
777static const struct xenbus_device_id xen_driver_ids[] = {
778 { XENDISPL_DRIVER_NAME },
779 { "" }
780};
781
782static struct xenbus_driver xen_driver = {
783 .ids = xen_driver_ids,
784 .probe = xen_drv_probe,
785 .remove = xen_drv_remove,
786 .otherend_changed = displback_changed,
787};
788
789static int __init xen_drv_init(void)
790{
791 /* At the moment we only support case with XEN_PAGE_SIZE == PAGE_SIZE */
792 if (XEN_PAGE_SIZE != PAGE_SIZE) {
793 DRM_ERROR(XENDISPL_DRIVER_NAME ": different kernel and Xen page sizes are not supported: XEN_PAGE_SIZE (%lu) != PAGE_SIZE (%lu)\n",
794 XEN_PAGE_SIZE, PAGE_SIZE);
795 return -ENODEV;
796 }
797
798 if (!xen_domain())
799 return -ENODEV;
800
801 if (!xen_has_pv_devices())
802 return -ENODEV;
803
804 DRM_INFO("Registering XEN PV " XENDISPL_DRIVER_NAME "\n");
805 return xenbus_register_frontend(&xen_driver);
806}
807
808static void __exit xen_drv_fini(void)
809{
810 DRM_INFO("Unregistering XEN PV " XENDISPL_DRIVER_NAME "\n");
811 xenbus_unregister_driver(&xen_driver);
812}
813
814module_init(xen_drv_init);
815module_exit(xen_drv_fini);
816
817MODULE_DESCRIPTION("Xen para-virtualized display device frontend");
818MODULE_LICENSE("GPL");
819MODULE_ALIAS("xen:" XENDISPL_DRIVER_NAME);