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);