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