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