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, 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 223fail: 224 mutex_unlock(&evtchnl->u.req.req_io_lock); 225fail_shbuf_alloc: 226 dbuf_free(&front_info->dbuf_list, dbuf_cookie); 227 return ret; 228} 229 230static 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 275int 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 315int 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 343int 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 372void 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 384static int xen_drm_drv_dumb_create(struct drm_file *filp, 385 struct drm_device *dev, 386 struct drm_mode_create_dumb *args) 387{ 388 struct xen_drm_front_drm_info *drm_info = dev->dev_private; 389 struct drm_gem_object *obj; 390 int ret; 391 392 /* 393 * Dumb creation is a two stage process: first we create a fully 394 * constructed GEM object which is communicated to the backend, and 395 * only after that we can create GEM's handle. This is done so, 396 * because of the possible races: once you create a handle it becomes 397 * immediately visible to user-space, so the latter can try accessing 398 * object without pages etc. 399 * For details also see drm_gem_handle_create 400 */ 401 args->pitch = DIV_ROUND_UP(args->width * args->bpp, 8); 402 args->size = args->pitch * args->height; 403 404 obj = xen_drm_front_gem_create(dev, args->size); 405 if (IS_ERR(obj)) { 406 ret = PTR_ERR(obj); 407 goto fail; 408 } 409 410 ret = xen_drm_front_dbuf_create(drm_info->front_info, 411 xen_drm_front_dbuf_to_cookie(obj), 412 args->width, args->height, args->bpp, 413 args->size, 0, 414 xen_drm_front_gem_get_pages(obj)); 415 if (ret) 416 goto fail_backend; 417 418 /* This is the tail of GEM object creation */ 419 ret = drm_gem_handle_create(filp, obj, &args->handle); 420 if (ret) 421 goto fail_handle; 422 423 /* Drop reference from allocate - handle holds it now */ 424 drm_gem_object_put(obj); 425 return 0; 426 427fail_handle: 428 xen_drm_front_dbuf_destroy(drm_info->front_info, 429 xen_drm_front_dbuf_to_cookie(obj)); 430fail_backend: 431 /* drop reference from allocate */ 432 drm_gem_object_put(obj); 433fail: 434 DRM_ERROR("Failed to create dumb buffer: %d\n", ret); 435 return ret; 436} 437 438static void xen_drm_drv_free_object_unlocked(struct drm_gem_object *obj) 439{ 440 struct xen_drm_front_drm_info *drm_info = obj->dev->dev_private; 441 int idx; 442 443 if (drm_dev_enter(obj->dev, &idx)) { 444 xen_drm_front_dbuf_destroy(drm_info->front_info, 445 xen_drm_front_dbuf_to_cookie(obj)); 446 drm_dev_exit(idx); 447 } else { 448 dbuf_free(&drm_info->front_info->dbuf_list, 449 xen_drm_front_dbuf_to_cookie(obj)); 450 } 451 452 xen_drm_front_gem_free_object_unlocked(obj); 453} 454 455static 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 472static 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 486static const struct vm_operations_struct xen_drm_drv_vm_ops = { 487 .open = drm_gem_vm_open, 488 .close = drm_gem_vm_close, 489}; 490 491static struct drm_driver xen_drm_driver = { 492 .driver_features = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC, 493 .release = xen_drm_drv_release, 494 .gem_vm_ops = &xen_drm_drv_vm_ops, 495 .gem_free_object_unlocked = xen_drm_drv_free_object_unlocked, 496 .prime_handle_to_fd = drm_gem_prime_handle_to_fd, 497 .prime_fd_to_handle = drm_gem_prime_fd_to_handle, 498 .gem_prime_import_sg_table = xen_drm_front_gem_import_sg_table, 499 .gem_prime_get_sg_table = xen_drm_front_gem_get_sg_table, 500 .gem_prime_vmap = xen_drm_front_gem_prime_vmap, 501 .gem_prime_vunmap = xen_drm_front_gem_prime_vunmap, 502 .gem_prime_mmap = xen_drm_front_gem_prime_mmap, 503 .dumb_create = xen_drm_drv_dumb_create, 504 .fops = &xen_drm_dev_fops, 505 .name = "xendrm-du", 506 .desc = "Xen PV DRM Display Unit", 507 .date = "20180221", 508 .major = 1, 509 .minor = 0, 510 511}; 512 513static int xen_drm_drv_init(struct xen_drm_front_info *front_info) 514{ 515 struct device *dev = &front_info->xb_dev->dev; 516 struct xen_drm_front_drm_info *drm_info; 517 struct drm_device *drm_dev; 518 int ret; 519 520 DRM_INFO("Creating %s\n", xen_drm_driver.desc); 521 522 drm_info = kzalloc(sizeof(*drm_info), GFP_KERNEL); 523 if (!drm_info) { 524 ret = -ENOMEM; 525 goto fail; 526 } 527 528 drm_info->front_info = front_info; 529 front_info->drm_info = drm_info; 530 531 drm_dev = drm_dev_alloc(&xen_drm_driver, dev); 532 if (IS_ERR(drm_dev)) { 533 ret = PTR_ERR(drm_dev); 534 goto fail_dev; 535 } 536 537 drm_info->drm_dev = drm_dev; 538 539 drm_dev->dev_private = drm_info; 540 541 ret = xen_drm_front_kms_init(drm_info); 542 if (ret) { 543 DRM_ERROR("Failed to initialize DRM/KMS, ret %d\n", ret); 544 goto fail_modeset; 545 } 546 547 ret = drm_dev_register(drm_dev, 0); 548 if (ret) 549 goto fail_register; 550 551 DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n", 552 xen_drm_driver.name, xen_drm_driver.major, 553 xen_drm_driver.minor, xen_drm_driver.patchlevel, 554 xen_drm_driver.date, drm_dev->primary->index); 555 556 return 0; 557 558fail_register: 559 drm_dev_unregister(drm_dev); 560fail_modeset: 561 drm_kms_helper_poll_fini(drm_dev); 562 drm_mode_config_cleanup(drm_dev); 563 drm_dev_put(drm_dev); 564fail_dev: 565 kfree(drm_info); 566 front_info->drm_info = NULL; 567fail: 568 return ret; 569} 570 571static void xen_drm_drv_fini(struct xen_drm_front_info *front_info) 572{ 573 struct xen_drm_front_drm_info *drm_info = front_info->drm_info; 574 struct drm_device *dev; 575 576 if (!drm_info) 577 return; 578 579 dev = drm_info->drm_dev; 580 if (!dev) 581 return; 582 583 /* Nothing to do if device is already unplugged */ 584 if (drm_dev_is_unplugged(dev)) 585 return; 586 587 drm_kms_helper_poll_fini(dev); 588 drm_dev_unplug(dev); 589 drm_dev_put(dev); 590 591 front_info->drm_info = NULL; 592 593 xen_drm_front_evtchnl_free_all(front_info); 594 dbuf_free_all(&front_info->dbuf_list); 595 596 /* 597 * If we are not using backend allocated buffers, then tell the 598 * backend we are ready to (re)initialize. Otherwise, wait for 599 * drm_driver.release. 600 */ 601 if (!front_info->cfg.be_alloc) 602 xenbus_switch_state(front_info->xb_dev, 603 XenbusStateInitialising); 604} 605 606static int displback_initwait(struct xen_drm_front_info *front_info) 607{ 608 struct xen_drm_front_cfg *cfg = &front_info->cfg; 609 int ret; 610 611 cfg->front_info = front_info; 612 ret = xen_drm_front_cfg_card(front_info, cfg); 613 if (ret < 0) 614 return ret; 615 616 DRM_INFO("Have %d connector(s)\n", cfg->num_connectors); 617 /* Create event channels for all connectors and publish */ 618 ret = xen_drm_front_evtchnl_create_all(front_info); 619 if (ret < 0) 620 return ret; 621 622 return xen_drm_front_evtchnl_publish_all(front_info); 623} 624 625static int displback_connect(struct xen_drm_front_info *front_info) 626{ 627 xen_drm_front_evtchnl_set_state(front_info, EVTCHNL_STATE_CONNECTED); 628 return xen_drm_drv_init(front_info); 629} 630 631static void displback_disconnect(struct xen_drm_front_info *front_info) 632{ 633 if (!front_info->drm_info) 634 return; 635 636 /* Tell the backend to wait until we release the DRM driver. */ 637 xenbus_switch_state(front_info->xb_dev, XenbusStateReconfiguring); 638 639 xen_drm_drv_fini(front_info); 640} 641 642static void displback_changed(struct xenbus_device *xb_dev, 643 enum xenbus_state backend_state) 644{ 645 struct xen_drm_front_info *front_info = dev_get_drvdata(&xb_dev->dev); 646 int ret; 647 648 DRM_DEBUG("Backend state is %s, front is %s\n", 649 xenbus_strstate(backend_state), 650 xenbus_strstate(xb_dev->state)); 651 652 switch (backend_state) { 653 case XenbusStateReconfiguring: 654 case XenbusStateReconfigured: 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 case XenbusStateClosed: 705 if (xb_dev->state == XenbusStateClosed) 706 break; 707 708 displback_disconnect(front_info); 709 break; 710 } 711} 712 713static int xen_drv_probe(struct xenbus_device *xb_dev, 714 const struct xenbus_device_id *id) 715{ 716 struct xen_drm_front_info *front_info; 717 struct device *dev = &xb_dev->dev; 718 int ret; 719 720 ret = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(64)); 721 if (ret < 0) { 722 DRM_ERROR("Cannot setup DMA mask, ret %d", ret); 723 return ret; 724 } 725 726 front_info = devm_kzalloc(&xb_dev->dev, 727 sizeof(*front_info), GFP_KERNEL); 728 if (!front_info) 729 return -ENOMEM; 730 731 front_info->xb_dev = xb_dev; 732 spin_lock_init(&front_info->io_lock); 733 INIT_LIST_HEAD(&front_info->dbuf_list); 734 dev_set_drvdata(&xb_dev->dev, front_info); 735 736 return xenbus_switch_state(xb_dev, XenbusStateInitialising); 737} 738 739static int xen_drv_remove(struct xenbus_device *dev) 740{ 741 struct xen_drm_front_info *front_info = dev_get_drvdata(&dev->dev); 742 int to = 100; 743 744 xenbus_switch_state(dev, XenbusStateClosing); 745 746 /* 747 * On driver removal it is disconnected from XenBus, 748 * so no backend state change events come via .otherend_changed 749 * callback. This prevents us from exiting gracefully, e.g. 750 * signaling the backend to free event channels, waiting for its 751 * state to change to XenbusStateClosed and cleaning at our end. 752 * Normally when front driver removed backend will finally go into 753 * XenbusStateInitWait state. 754 * 755 * Workaround: read backend's state manually and wait with time-out. 756 */ 757 while ((xenbus_read_unsigned(front_info->xb_dev->otherend, "state", 758 XenbusStateUnknown) != XenbusStateInitWait) && 759 --to) 760 msleep(10); 761 762 if (!to) { 763 unsigned int state; 764 765 state = xenbus_read_unsigned(front_info->xb_dev->otherend, 766 "state", XenbusStateUnknown); 767 DRM_ERROR("Backend state is %s while removing driver\n", 768 xenbus_strstate(state)); 769 } 770 771 xen_drm_drv_fini(front_info); 772 xenbus_frontend_closed(dev); 773 return 0; 774} 775 776static const struct xenbus_device_id xen_driver_ids[] = { 777 { XENDISPL_DRIVER_NAME }, 778 { "" } 779}; 780 781static struct xenbus_driver xen_driver = { 782 .ids = xen_driver_ids, 783 .probe = xen_drv_probe, 784 .remove = xen_drv_remove, 785 .otherend_changed = displback_changed, 786}; 787 788static int __init xen_drv_init(void) 789{ 790 /* At the moment we only support case with XEN_PAGE_SIZE == PAGE_SIZE */ 791 if (XEN_PAGE_SIZE != PAGE_SIZE) { 792 DRM_ERROR(XENDISPL_DRIVER_NAME ": different kernel and Xen page sizes are not supported: XEN_PAGE_SIZE (%lu) != PAGE_SIZE (%lu)\n", 793 XEN_PAGE_SIZE, PAGE_SIZE); 794 return -ENODEV; 795 } 796 797 if (!xen_domain()) 798 return -ENODEV; 799 800 if (!xen_has_pv_devices()) 801 return -ENODEV; 802 803 DRM_INFO("Registering XEN PV " XENDISPL_DRIVER_NAME "\n"); 804 return xenbus_register_frontend(&xen_driver); 805} 806 807static void __exit xen_drv_fini(void) 808{ 809 DRM_INFO("Unregistering XEN PV " XENDISPL_DRIVER_NAME "\n"); 810 xenbus_unregister_driver(&xen_driver); 811} 812 813module_init(xen_drv_init); 814module_exit(xen_drv_fini); 815 816MODULE_DESCRIPTION("Xen para-virtualized display device frontend"); 817MODULE_LICENSE("GPL"); 818MODULE_ALIAS("xen:" XENDISPL_DRIVER_NAME); 819