drivers/gpu/drm/xen/xen_drm_front.c

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