drivers/video/adf/adf.c

   1 /*
   2  * Copyright (C) 2013 Google, Inc.
   3  * adf_modeinfo_{set_name,set_vrefresh} modified from
   4  * drivers/gpu/drm/drm_modes.c
   5  * adf_format_validate_yuv modified from framebuffer_check in
   6  * drivers/gpu/drm/drm_crtc.c
   7  *
   8  * This software is licensed under the terms of the GNU General Public
   9  * License version 2, as published by the Free Software Foundation, and
  10  * may be copied, distributed, and modified under those terms.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  */
  18
  19 #include <linux/device.h>
  20 #include <linux/idr.h>
  21 #include <linux/highmem.h>
  22 #include <linux/memblock.h>
  23 #include <linux/module.h>
  24 #include <linux/platform_device.h>
  25 #include <linux/slab.h>
  26
  27 #include <video/adf_format.h>
  28
  29 #include "sw_sync.h"
  30 #include "sync.h"
  31
  32 #include "adf.h"
  33 #include "adf_fops.h"
  34 #include "adf_sysfs.h"
  35
  36 #define CREATE_TRACE_POINTS
  37 #include "adf_trace.h"
  38
  39 #define ADF_SHORT_FENCE_TIMEOUT (1 * MSEC_PER_SEC)
  40 #define ADF_LONG_FENCE_TIMEOUT (10 * MSEC_PER_SEC)
  41
  42 static DEFINE_IDR(adf_devices);
  43
  44 static void adf_fence_wait(struct adf_device *dev, struct sync_fence *fence)
  45 {
  46         /* sync_fence_wait() dumps debug information on timeout.  Experience
  47            has shown that if the pipeline gets stuck, a short timeout followed
  48            by a longer one provides useful information for debugging. */
  49         int err = sync_fence_wait(fence, ADF_SHORT_FENCE_TIMEOUT);
  50         if (err >= 0)
  51                 return;
  52
  53         if (err == -ETIME)
  54                 err = sync_fence_wait(fence, ADF_LONG_FENCE_TIMEOUT);
  55
  56         if (err < 0)
  57                 dev_warn(&dev->base.dev, "error waiting on fence: %d\n", err);
  58 }
  59
  60 void adf_buffer_cleanup(struct adf_buffer *buf)
  61 {
  62         size_t i;
  63         for (i = 0; i < ARRAY_SIZE(buf->dma_bufs); i++)
  64                 if (buf->dma_bufs[i])
  65                         dma_buf_put(buf->dma_bufs[i]);
  66
  67         if (buf->acquire_fence)
  68                 sync_fence_put(buf->acquire_fence);
  69 }
  70
  71 void adf_buffer_mapping_cleanup(struct adf_buffer_mapping *mapping,
  72                 struct adf_buffer *buf)
  73 {
  74         /* calling adf_buffer_mapping_cleanup() is safe even if mapping is
  75            uninitialized or partially-initialized, as long as it was
  76            zeroed on allocation */
  77         size_t i;
  78         for (i = 0; i < ARRAY_SIZE(mapping->sg_tables); i++) {
  79                 if (mapping->sg_tables[i])
  80                         dma_buf_unmap_attachment(mapping->attachments[i],
  81                                         mapping->sg_tables[i], DMA_TO_DEVICE);
  82                 if (mapping->attachments[i])
  83                         dma_buf_detach(buf->dma_bufs[i],
  84                                         mapping->attachments[i]);
  85         }
  86 }
  87
  88 void adf_post_cleanup(struct adf_device *dev, struct adf_pending_post *post)
  89 {
  90         size_t i;
  91
  92         if (post->state)
  93                 dev->ops->state_free(dev, post->state);
  94
  95         for (i = 0; i < post->config.n_bufs; i++) {
  96                 adf_buffer_mapping_cleanup(&post->config.mappings[i],
  97                                 &post->config.bufs[i]);
  98                 adf_buffer_cleanup(&post->config.bufs[i]);
  99         }
 100
 101         kfree(post->config.custom_data);
 102         kfree(post->config.mappings);
 103         kfree(post->config.bufs);
 104         kfree(post);
 105 }
 106
 107 static void adf_sw_advance_timeline(struct adf_device *dev)
 108 {
 109 #ifdef CONFIG_SW_SYNC
 110         sw_sync_timeline_inc(dev->timeline, 1);
 111 #else
 112         BUG();
 113 #endif
 114 }
 115
 116 static void adf_post_work_func(struct kthread_work *work)
 117 {
 118         struct adf_device *dev =
 119                         container_of(work, struct adf_device, post_work);
 120         struct adf_pending_post *post, *next;
 121         struct list_head saved_list;
 122
 123         mutex_lock(&dev->post_lock);
 124         memcpy(&saved_list, &dev->post_list, sizeof(saved_list));
 125         list_replace_init(&dev->post_list, &saved_list);
 126         mutex_unlock(&dev->post_lock);
 127
 128         list_for_each_entry_safe(post, next, &saved_list, head) {
 129                 int i;
 130
 131                 for (i = 0; i < post->config.n_bufs; i++) {
 132                         struct sync_fence *fence =
 133                                         post->config.bufs[i].acquire_fence;
 134                         if (fence)
 135                                 adf_fence_wait(dev, fence);
 136                 }
 137
 138                 dev->ops->post(dev, &post->config, post->state);
 139
 140                 if (dev->ops->advance_timeline)
 141                         dev->ops->advance_timeline(dev, &post->config,
 142                                         post->state);
 143                 else
 144                         adf_sw_advance_timeline(dev);
 145
 146                 list_del(&post->head);
 147                 if (dev->onscreen)
 148                         adf_post_cleanup(dev, dev->onscreen);
 149                 dev->onscreen = post;
 150         }
 151 }
 152
 153 void adf_attachment_free(struct adf_attachment_list *attachment)
 154 {
 155         list_del(&attachment->head);
 156         kfree(attachment);
 157 }
 158
 159 struct adf_event_refcount *adf_obj_find_event_refcount(struct adf_obj *obj,
 160                 enum adf_event_type type)
 161 {
 162         struct rb_root *root = &obj->event_refcount;
 163         struct rb_node **new = &(root->rb_node);
 164         struct rb_node *parent = NULL;
 165         struct adf_event_refcount *refcount;
 166
 167         while (*new) {
 168                 refcount = container_of(*new, struct adf_event_refcount, node);
 169                 parent = *new;
 170
 171                 if (refcount->type > type)
 172                         new = &(*new)->rb_left;
 173                 else if (refcount->type < type)
 174                         new = &(*new)->rb_right;
 175                 else
 176                         return refcount;
 177         }
 178
 179         refcount = kzalloc(sizeof(*refcount), GFP_KERNEL);
 180         if (!refcount)
 181                 return NULL;
 182         refcount->type = type;
 183
 184         rb_link_node(&refcount->node, parent, new);
 185         rb_insert_color(&refcount->node, root);
 186         return refcount;
 187 }
 188
 189 /**
 190  * adf_event_get - increase the refcount for an event
 191  *
 192  * @obj: the object that produces the event
 193  * @type: the event type
 194  *
 195  * ADF will call the object's set_event() op if needed.  ops are allowed
 196  * to sleep, so adf_event_get() must NOT be called from an atomic context.
 197  *
 198  * Returns 0 if successful, or -%EINVAL if the object does not support the
 199  * requested event type.
 200  */
 201 int adf_event_get(struct adf_obj *obj, enum adf_event_type type)
 202 {
 203         struct adf_event_refcount *refcount;
 204         int old_refcount;
 205         int ret;
 206
 207         ret = adf_obj_check_supports_event(obj, type);
 208         if (ret < 0)
 209                 return ret;
 210
 211         mutex_lock(&obj->event_lock);
 212
 213         refcount = adf_obj_find_event_refcount(obj, type);
 214         if (!refcount) {
 215                 ret = -ENOMEM;
 216                 goto done;
 217         }
 218
 219         old_refcount = refcount->refcount++;
 220
 221         if (old_refcount == 0) {
 222                 obj->ops->set_event(obj, type, true);
 223                 trace_adf_event_enable(obj, type);
 224         }
 225
 226 done:
 227         mutex_unlock(&obj->event_lock);
 228         return ret;
 229 }
 230 EXPORT_SYMBOL(adf_event_get);
 231
 232 /**
 233  * adf_event_put - decrease the refcount for an event
 234  *
 235  * @obj: the object that produces the event
 236  * @type: the event type
 237  *
 238  * ADF will call the object's set_event() op if needed.  ops are allowed
 239  * to sleep, so adf_event_put() must NOT be called from an atomic context.
 240  *
 241  * Returns 0 if successful, -%EINVAL if the object does not support the
 242  * requested event type, or -%EALREADY if the refcount is already 0.
 243  */
 244 int adf_event_put(struct adf_obj *obj, enum adf_event_type type)
 245 {
 246         struct adf_event_refcount *refcount;
 247         int old_refcount;
 248         int ret;
 249
 250         ret = adf_obj_check_supports_event(obj, type);
 251         if (ret < 0)
 252                 return ret;
 253
 254
 255         mutex_lock(&obj->event_lock);
 256
 257         refcount = adf_obj_find_event_refcount(obj, type);
 258         if (!refcount) {
 259                 ret = -ENOMEM;
 260                 goto done;
 261         }
 262
 263         old_refcount = refcount->refcount--;
 264
 265         if (WARN_ON(old_refcount == 0)) {
 266                 refcount->refcount++;
 267                 ret = -EALREADY;
 268         } else if (old_refcount == 1) {
 269                 obj->ops->set_event(obj, type, false);
 270                 trace_adf_event_disable(obj, type);
 271         }
 272
 273 done:
 274         mutex_unlock(&obj->event_lock);
 275         return ret;
 276 }
 277 EXPORT_SYMBOL(adf_event_put);
 278
 279 /**
 280  * adf_vsync_wait - wait for a vsync event on a display interface
 281  *
 282  * @intf: the display interface
 283  * @timeout: timeout in jiffies (0 = wait indefinitely)
 284  *
 285  * adf_vsync_wait() may sleep, so it must NOT be called from an atomic context.
 286  *
 287  * This function returns -%ERESTARTSYS if it is interrupted by a signal.
 288  * If @timeout == 0 then this function returns 0 on vsync. If @timeout > 0 then
 289  * this function returns the number of remaining jiffies or -%ETIMEDOUT on
 290  * timeout.
 291  */
 292 int adf_vsync_wait(struct adf_interface *intf, long timeout)
 293 {
 294         ktime_t timestamp;
 295         int ret;
 296         unsigned long flags;
 297
 298         read_lock_irqsave(&intf->vsync_lock, flags);
 299         timestamp = intf->vsync_timestamp;
 300         read_unlock_irqrestore(&intf->vsync_lock, flags);
 301
 302         adf_vsync_get(intf);
 303         if (timeout) {
 304                 ret = wait_event_interruptible_timeout(intf->vsync_wait,
 305                                 !ktime_equal(timestamp,
 306                                                 intf->vsync_timestamp),
 307                                 msecs_to_jiffies(timeout));
 308                 if (ret == 0 && ktime_equal(timestamp, intf->vsync_timestamp))
 309                         ret = -ETIMEDOUT;
 310         } else {
 311                 ret = wait_event_interruptible(intf->vsync_wait,
 312                                 !ktime_equal(timestamp,
 313                                                 intf->vsync_timestamp));
 314         }
 315         adf_vsync_put(intf);
 316
 317         return ret;
 318 }
 319 EXPORT_SYMBOL(adf_vsync_wait);
 320
 321 static void adf_event_queue(struct adf_obj *obj, struct adf_event *event)
 322 {
 323         struct adf_file *file;
 324         unsigned long flags;
 325
 326         trace_adf_event(obj, event->type);
 327
 328         spin_lock_irqsave(&obj->file_lock, flags);
 329
 330         list_for_each_entry(file, &obj->file_list, head)
 331                 if (test_bit(event->type, file->event_subscriptions))
 332                         adf_file_queue_event(file, event);
 333
 334         spin_unlock_irqrestore(&obj->file_lock, flags);
 335 }
 336
 337 /**
 338  * adf_event_notify - notify userspace of a driver-private event
 339  *
 340  * @obj: the ADF object that produced the event
 341  * @event: the event
 342  *
 343  * adf_event_notify() may be called safely from an atomic context.  It will
 344  * copy @event if needed, so @event may point to a variable on the stack.
 345  *
 346  * Drivers must NOT call adf_event_notify() for vsync and hotplug events.
 347  * ADF provides adf_vsync_notify() and
 348  * adf_hotplug_notify_{connected,disconnected}() for these events.
 349  */
 350 int adf_event_notify(struct adf_obj *obj, struct adf_event *event)
 351 {
 352         if (WARN_ON(event->type == ADF_EVENT_VSYNC ||
 353                         event->type == ADF_EVENT_HOTPLUG))
 354                 return -EINVAL;
 355
 356         adf_event_queue(obj, event);
 357         return 0;
 358 }
 359 EXPORT_SYMBOL(adf_event_notify);
 360
 361 /**
 362  * adf_vsync_notify - notify ADF of a display interface's vsync event
 363  *
 364  * @intf: the display interface
 365  * @timestamp: the time the vsync occurred
 366  *
 367  * adf_vsync_notify() may be called safely from an atomic context.
 368  */
 369 void adf_vsync_notify(struct adf_interface *intf, ktime_t timestamp)
 370 {
 371         unsigned long flags;
 372         struct adf_vsync_event event;
 373
 374         write_lock_irqsave(&intf->vsync_lock, flags);
 375         intf->vsync_timestamp = timestamp;
 376         write_unlock_irqrestore(&intf->vsync_lock, flags);
 377
 378         wake_up_interruptible_all(&intf->vsync_wait);
 379
 380         event.base.type = ADF_EVENT_VSYNC;
 381         event.base.length = sizeof(event);
 382         event.timestamp = ktime_to_ns(timestamp);
 383         adf_event_queue(&intf->base, &event.base);
 384 }
 385 EXPORT_SYMBOL(adf_vsync_notify);
 386
 387 void adf_hotplug_notify(struct adf_interface *intf, bool connected,
 388                 struct drm_mode_modeinfo *modelist, size_t n_modes)
 389 {
 390         unsigned long flags;
 391         struct adf_hotplug_event event;
 392         struct drm_mode_modeinfo *old_modelist;
 393
 394         write_lock_irqsave(&intf->hotplug_modelist_lock, flags);
 395         old_modelist = intf->modelist;
 396         intf->hotplug_detect = connected;
 397         intf->modelist = modelist;
 398         intf->n_modes = n_modes;
 399         write_unlock_irqrestore(&intf->hotplug_modelist_lock, flags);
 400
 401         kfree(old_modelist);
 402
 403         event.base.length = sizeof(event);
 404         event.base.type = ADF_EVENT_HOTPLUG;
 405         event.connected = connected;
 406         adf_event_queue(&intf->base, &event.base);
 407 }
 408
 409 /**
 410  * adf_hotplug_notify_connected - notify ADF of a display interface being
 411  * connected to a display
 412  *
 413  * @intf: the display interface
 414  * @modelist: hardware modes supported by display
 415  * @n_modes: length of modelist
 416  *
 417  * @modelist is copied as needed, so it may point to a variable on the stack.
 418  *
 419  * adf_hotplug_notify_connected() may NOT be called safely from an atomic
 420  * context.
 421  *
 422  * Returns 0 on success or error code (<0) on error.
 423  */
 424 int adf_hotplug_notify_connected(struct adf_interface *intf,
 425                 struct drm_mode_modeinfo *modelist, size_t n_modes)
 426 {
 427         struct drm_mode_modeinfo *modelist_copy;
 428
 429         if (n_modes > ADF_MAX_MODES)
 430                 return -ENOMEM;
 431
 432         modelist_copy = kzalloc(sizeof(modelist_copy[0]) * n_modes,
 433                         GFP_KERNEL);
 434         if (!modelist_copy)
 435                 return -ENOMEM;
 436         memcpy(modelist_copy, modelist, sizeof(modelist_copy[0]) * n_modes);
 437
 438         adf_hotplug_notify(intf, true, modelist_copy, n_modes);
 439         return 0;
 440 }
 441 EXPORT_SYMBOL(adf_hotplug_notify_connected);
 442
 443 /**
 444  * adf_hotplug_notify_disconnected - notify ADF of a display interface being
 445  * disconnected from a display
 446  *
 447  * @intf: the display interface
 448  *
 449  * adf_hotplug_notify_disconnected() may be called safely from an atomic
 450  * context.
 451  */
 452 void adf_hotplug_notify_disconnected(struct adf_interface *intf)
 453 {
 454         adf_hotplug_notify(intf, false, NULL, 0);
 455 }
 456 EXPORT_SYMBOL(adf_hotplug_notify_disconnected);
 457
 458 static int adf_obj_init(struct adf_obj *obj, enum adf_obj_type type,
 459                 struct idr *idr, struct adf_device *parent,
 460                 const struct adf_obj_ops *ops, const char *fmt, va_list args)
 461 {
 462         int ret;
 463
 464         if (ops && ops->supports_event && !ops->set_event) {
 465                 pr_err("%s: %s implements supports_event but not set_event\n",
 466                                 __func__, adf_obj_type_str(type));
 467                 return -EINVAL;
 468         }
 469
 470         ret = idr_alloc(idr, obj, 0, 0, GFP_KERNEL);
 471         if (ret < 0) {
 472                 pr_err("%s: allocating object id failed: %d\n", __func__, ret);
 473                 return ret;
 474         }
 475         obj->id = ret;
 476
 477         vscnprintf(obj->name, sizeof(obj->name), fmt, args);
 478
 479         obj->type = type;
 480         obj->ops = ops;
 481         obj->parent = parent;
 482         mutex_init(&obj->event_lock);
 483         obj->event_refcount = RB_ROOT;
 484         spin_lock_init(&obj->file_lock);
 485         INIT_LIST_HEAD(&obj->file_list);
 486         return 0;
 487 }
 488
 489 static void adf_obj_destroy(struct adf_obj *obj, struct idr *idr)
 490 {
 491         struct rb_node *node = rb_first(&obj->event_refcount);
 492
 493         while (node) {
 494                 struct adf_event_refcount *refcount =
 495                                 container_of(node, struct adf_event_refcount,
 496                                                 node);
 497                 rb_erase(&refcount->node, &obj->event_refcount);
 498                 kfree(refcount);
 499                 node = rb_first(&obj->event_refcount);
 500         }
 501
 502         mutex_destroy(&obj->event_lock);
 503         idr_remove(idr, obj->id);
 504 }
 505
 506 /**
 507  * adf_device_init - initialize ADF-internal data for a display device
 508  * and create sysfs entries
 509  *
 510  * @dev: the display device
 511  * @parent: the device's parent device
 512  * @ops: the device's associated ops
 513  * @fmt: formatting string for the display device's name
 514  *
 515  * @fmt specifies the device's sysfs filename and the name returned to
 516  * userspace through the %ADF_GET_DEVICE_DATA ioctl.
 517  *
 518  * Returns 0 on success or error code (<0) on failure.
 519  */
 520 int adf_device_init(struct adf_device *dev, struct device *parent,
 521                 const struct adf_device_ops *ops, const char *fmt, ...)
 522 {
 523         int ret;
 524         va_list args;
 525
 526         if (!ops->validate || !ops->post) {
 527                 pr_err("%s: device must implement validate and post\n",
 528                                 __func__);
 529                 return -EINVAL;
 530         }
 531
 532         if (!ops->complete_fence && !ops->advance_timeline) {
 533                 if (!IS_ENABLED(CONFIG_SW_SYNC)) {
 534                         pr_err("%s: device requires sw_sync but it is not enabled in the kernel\n",
 535                                         __func__);
 536                         return -EINVAL;
 537                 }
 538         } else if (!(ops->complete_fence && ops->advance_timeline)) {
 539                 pr_err("%s: device must implement both complete_fence and advance_timeline, or implement neither\n",
 540                                 __func__);
 541                 return -EINVAL;
 542         }
 543
 544         memset(dev, 0, sizeof(*dev));
 545
 546         va_start(args, fmt);
 547         ret = adf_obj_init(&dev->base, ADF_OBJ_DEVICE, &adf_devices, dev,
 548                         &ops->base, fmt, args);
 549         va_end(args);
 550         if (ret < 0)
 551                 return ret;
 552
 553         dev->dev = parent;
 554         dev->ops = ops;
 555         idr_init(&dev->overlay_engines);
 556         idr_init(&dev->interfaces);
 557         mutex_init(&dev->client_lock);
 558         INIT_LIST_HEAD(&dev->post_list);
 559         mutex_init(&dev->post_lock);
 560         init_kthread_worker(&dev->post_worker);
 561         INIT_LIST_HEAD(&dev->attached);
 562         INIT_LIST_HEAD(&dev->attach_allowed);
 563
 564         dev->post_thread = kthread_run(kthread_worker_fn,
 565                         &dev->post_worker, dev->base.name);
 566         if (IS_ERR(dev->post_thread)) {
 567                 ret = PTR_ERR(dev->post_thread);
 568                 dev->post_thread = NULL;
 569
 570                 pr_err("%s: failed to run config posting thread: %d\n",
 571                                 __func__, ret);
 572                 goto err;
 573         }
 574         init_kthread_work(&dev->post_work, adf_post_work_func);
 575
 576         ret = adf_device_sysfs_init(dev);
 577         if (ret < 0)
 578                 goto err;
 579
 580         return 0;
 581
 582 err:
 583         adf_device_destroy(dev);
 584         return ret;
 585 }
 586 EXPORT_SYMBOL(adf_device_init);
 587
 588 /**
 589  * adf_device_destroy - clean up ADF-internal data for a display device
 590  *
 591  * @dev: the display device
 592  */
 593 void adf_device_destroy(struct adf_device *dev)
 594 {
 595         struct adf_attachment_list *entry, *next;
 596
 597         idr_destroy(&dev->interfaces);
 598         idr_destroy(&dev->overlay_engines);
 599
 600         if (dev->post_thread) {
 601                 flush_kthread_worker(&dev->post_worker);
 602                 kthread_stop(dev->post_thread);
 603         }
 604
 605         if (dev->onscreen)
 606                 adf_post_cleanup(dev, dev->onscreen);
 607         adf_device_sysfs_destroy(dev);
 608         list_for_each_entry_safe(entry, next, &dev->attach_allowed, head) {
 609                 adf_attachment_free(entry);
 610         }
 611         list_for_each_entry_safe(entry, next, &dev->attached, head) {
 612                 adf_attachment_free(entry);
 613         }
 614         mutex_destroy(&dev->post_lock);
 615         mutex_destroy(&dev->client_lock);
 616         adf_obj_destroy(&dev->base, &adf_devices);
 617 }
 618 EXPORT_SYMBOL(adf_device_destroy);
 619
 620 /**
 621  * adf_interface_init - initialize ADF-internal data for a display interface
 622  * and create sysfs entries
 623  *
 624  * @intf: the display interface
 625  * @dev: the interface's "parent" display device
 626  * @type: interface type (see enum @adf_interface_type)
 627  * @idx: which interface of type @type;
 628  *      e.g. interface DSI.1 -> @type=%ADF_INTF_TYPE_DSI, @idx=1
 629  * @flags: informational flags (bitmask of %ADF_INTF_FLAG_* values)
 630  * @ops: the interface's associated ops
 631  * @fmt: formatting string for the display interface's name
 632  *
 633  * @dev must have previously been initialized with adf_device_init().
 634  *
 635  * @fmt affects the name returned to userspace through the
 636  * %ADF_GET_INTERFACE_DATA ioctl.  It does not affect the sysfs filename,
 637  * which is derived from @dev's name.
 638  *
 639  * Returns 0 on success or error code (<0) on failure.
 640  */
 641 int adf_interface_init(struct adf_interface *intf, struct adf_device *dev,
 642                 enum adf_interface_type type, u32 idx, u32 flags,
 643                 const struct adf_interface_ops *ops, const char *fmt, ...)
 644 {
 645         int ret;
 646         va_list args;
 647         const u32 allowed_flags = ADF_INTF_FLAG_PRIMARY |
 648                         ADF_INTF_FLAG_EXTERNAL;
 649
 650         if (dev->n_interfaces == ADF_MAX_INTERFACES) {
 651                 pr_err("%s: parent device %s has too many interfaces\n",
 652                                 __func__, dev->base.name);
 653                 return -ENOMEM;
 654         }
 655
 656         if (type >= ADF_INTF_MEMORY && type <= ADF_INTF_TYPE_DEVICE_CUSTOM) {
 657                 pr_err("%s: invalid interface type %u\n", __func__, type);
 658                 return -EINVAL;
 659         }
 660
 661         if (flags & ~allowed_flags) {
 662                 pr_err("%s: invalid interface flags 0x%X\n", __func__,
 663                                 flags & ~allowed_flags);
 664                 return -EINVAL;
 665         }
 666
 667         memset(intf, 0, sizeof(*intf));
 668
 669         va_start(args, fmt);
 670         ret = adf_obj_init(&intf->base, ADF_OBJ_INTERFACE, &dev->interfaces,
 671                         dev, ops ? &ops->base : NULL, fmt, args);
 672         va_end(args);
 673         if (ret < 0)
 674                 return ret;
 675
 676         intf->type = type;
 677         intf->idx = idx;
 678         intf->flags = flags;
 679         intf->ops = ops;
 680         intf->dpms_state = DRM_MODE_DPMS_OFF;
 681         init_waitqueue_head(&intf->vsync_wait);
 682         rwlock_init(&intf->vsync_lock);
 683         rwlock_init(&intf->hotplug_modelist_lock);
 684
 685         ret = adf_interface_sysfs_init(intf);
 686         if (ret < 0)
 687                 goto err;
 688         dev->n_interfaces++;
 689
 690         return 0;
 691
 692 err:
 693         adf_obj_destroy(&intf->base, &dev->interfaces);
 694         return ret;
 695 }
 696 EXPORT_SYMBOL(adf_interface_init);
 697
 698 /**
 699  * adf_interface_destroy - clean up ADF-internal data for a display interface
 700  *
 701  * @intf: the display interface
 702  */
 703 void adf_interface_destroy(struct adf_interface *intf)
 704 {
 705         struct adf_device *dev = adf_interface_parent(intf);
 706         struct adf_attachment_list *entry, *next;
 707
 708         mutex_lock(&dev->client_lock);
 709         list_for_each_entry_safe(entry, next, &dev->attach_allowed, head) {
 710                 if (entry->attachment.interface == intf) {
 711                         adf_attachment_free(entry);
 712                         dev->n_attach_allowed--;
 713                 }
 714         }
 715         list_for_each_entry_safe(entry, next, &dev->attached, head) {
 716                 if (entry->attachment.interface == intf) {
 717                         adf_device_detach_op(dev,
 718                                         entry->attachment.overlay_engine, intf);
 719                         adf_attachment_free(entry);
 720                         dev->n_attached--;
 721                 }
 722         }
 723         kfree(intf->modelist);
 724         adf_interface_sysfs_destroy(intf);
 725         adf_obj_destroy(&intf->base, &dev->interfaces);
 726         dev->n_interfaces--;
 727         mutex_unlock(&dev->client_lock);
 728 }
 729 EXPORT_SYMBOL(adf_interface_destroy);
 730
 731 static bool adf_overlay_engine_has_custom_formats(
 732                 const struct adf_overlay_engine_ops *ops)
 733 {
 734         size_t i;
 735         for (i = 0; i < ops->n_supported_formats; i++)
 736                 if (!adf_format_is_standard(ops->supported_formats[i]))
 737                         return true;
 738         return false;
 739 }
 740
 741 /**
 742  * adf_overlay_engine_init - initialize ADF-internal data for an
 743  * overlay engine and create sysfs entries
 744  *
 745  * @eng: the overlay engine
 746  * @dev: the overlay engine's "parent" display device
 747  * @ops: the overlay engine's associated ops
 748  * @fmt: formatting string for the overlay engine's name
 749  *
 750  * @dev must have previously been initialized with adf_device_init().
 751  *
 752  * @fmt affects the name returned to userspace through the
 753  * %ADF_GET_OVERLAY_ENGINE_DATA ioctl.  It does not affect the sysfs filename,
 754  * which is derived from @dev's name.
 755  *
 756  * Returns 0 on success or error code (<0) on failure.
 757  */
 758 int adf_overlay_engine_init(struct adf_overlay_engine *eng,
 759                 struct adf_device *dev,
 760                 const struct adf_overlay_engine_ops *ops, const char *fmt, ...)
 761 {
 762         int ret;
 763         va_list args;
 764
 765         if (!ops->supported_formats) {
 766                 pr_err("%s: overlay engine must support at least one format\n",
 767                                 __func__);
 768                 return -EINVAL;
 769         }
 770
 771         if (ops->n_supported_formats > ADF_MAX_SUPPORTED_FORMATS) {
 772                 pr_err("%s: overlay engine supports too many formats\n",
 773                                 __func__);
 774                 return -EINVAL;
 775         }
 776
 777         if (adf_overlay_engine_has_custom_formats(ops) &&
 778                         !dev->ops->validate_custom_format) {
 779                 pr_err("%s: overlay engine has custom formats but parent device %s does not implement validate_custom_format\n",
 780                                 __func__, dev->base.name);
 781                 return -EINVAL;
 782         }
 783
 784         memset(eng, 0, sizeof(*eng));
 785
 786         va_start(args, fmt);
 787         ret = adf_obj_init(&eng->base, ADF_OBJ_OVERLAY_ENGINE,
 788                         &dev->overlay_engines, dev, &ops->base, fmt, args);
 789         va_end(args);
 790         if (ret < 0)
 791                 return ret;
 792
 793         eng->ops = ops;
 794
 795         ret = adf_overlay_engine_sysfs_init(eng);
 796         if (ret < 0)
 797                 goto err;
 798
 799         return 0;
 800
 801 err:
 802         adf_obj_destroy(&eng->base, &dev->overlay_engines);
 803         return ret;
 804 }
 805 EXPORT_SYMBOL(adf_overlay_engine_init);
 806
 807 /**
 808  * adf_interface_destroy - clean up ADF-internal data for an overlay engine
 809  *
 810  * @eng: the overlay engine
 811  */
 812 void adf_overlay_engine_destroy(struct adf_overlay_engine *eng)
 813 {
 814         struct adf_device *dev = adf_overlay_engine_parent(eng);
 815         struct adf_attachment_list *entry, *next;
 816
 817         mutex_lock(&dev->client_lock);
 818         list_for_each_entry_safe(entry, next, &dev->attach_allowed, head) {
 819                 if (entry->attachment.overlay_engine == eng) {
 820                         adf_attachment_free(entry);
 821                         dev->n_attach_allowed--;
 822                 }
 823         }
 824         list_for_each_entry_safe(entry, next, &dev->attached, head) {
 825                 if (entry->attachment.overlay_engine == eng) {
 826                         adf_device_detach_op(dev, eng,
 827                                         entry->attachment.interface);
 828                         adf_attachment_free(entry);
 829                         dev->n_attached--;
 830                 }
 831         }
 832         adf_overlay_engine_sysfs_destroy(eng);
 833         adf_obj_destroy(&eng->base, &dev->overlay_engines);
 834         mutex_unlock(&dev->client_lock);
 835 }
 836 EXPORT_SYMBOL(adf_overlay_engine_destroy);
 837
 838 struct adf_attachment_list *adf_attachment_find(struct list_head *list,
 839                 struct adf_overlay_engine *eng, struct adf_interface *intf)
 840 {
 841         struct adf_attachment_list *entry;
 842         list_for_each_entry(entry, list, head) {
 843                 if (entry->attachment.interface == intf &&
 844                                 entry->attachment.overlay_engine == eng)
 845                         return entry;
 846         }
 847         return NULL;
 848 }
 849
 850 int adf_attachment_validate(struct adf_device *dev,
 851                 struct adf_overlay_engine *eng, struct adf_interface *intf)
 852 {
 853         struct adf_device *intf_dev = adf_interface_parent(intf);
 854         struct adf_device *eng_dev = adf_overlay_engine_parent(eng);
 855
 856         if (intf_dev != dev) {
 857                 dev_err(&dev->base.dev, "can't attach interface %s belonging to device %s\n",
 858                                 intf->base.name, intf_dev->base.name);
 859                 return -EINVAL;
 860         }
 861
 862         if (eng_dev != dev) {
 863                 dev_err(&dev->base.dev, "can't attach overlay engine %s belonging to device %s\n",
 864                                 eng->base.name, eng_dev->base.name);
 865                 return -EINVAL;
 866         }
 867
 868         return 0;
 869 }
 870
 871 /**
 872  * adf_attachment_allow - add a new entry to the list of allowed
 873  * attachments
 874  *
 875  * @dev: the parent device
 876  * @eng: the overlay engine
 877  * @intf: the interface
 878  *
 879  * adf_attachment_allow() indicates that the underlying display hardware allows
 880  * @intf to scan out @eng's output.  It is intended to be called at
 881  * driver initialization for each supported overlay engine + interface pair.
 882  *
 883  * Returns 0 on success, -%EALREADY if the entry already exists, or -errno on
 884  * any other failure.
 885  */
 886 int adf_attachment_allow(struct adf_device *dev,
 887                 struct adf_overlay_engine *eng, struct adf_interface *intf)
 888 {
 889         int ret;
 890         struct adf_attachment_list *entry = NULL;
 891
 892         ret = adf_attachment_validate(dev, eng, intf);
 893         if (ret < 0)
 894                 return ret;
 895
 896         mutex_lock(&dev->client_lock);
 897
 898         if (dev->n_attach_allowed == ADF_MAX_ATTACHMENTS) {
 899                 ret = -ENOMEM;
 900                 goto done;
 901         }
 902
 903         if (adf_attachment_find(&dev->attach_allowed, eng, intf)) {
 904                 ret = -EALREADY;
 905                 goto done;
 906         }
 907
 908         entry = kzalloc(sizeof(*entry), GFP_KERNEL);
 909         if (!entry) {
 910                 ret = -ENOMEM;
 911                 goto done;
 912         }
 913
 914         entry->attachment.interface = intf;
 915         entry->attachment.overlay_engine = eng;
 916         list_add_tail(&entry->head, &dev->attach_allowed);
 917         dev->n_attach_allowed++;
 918
 919 done:
 920         mutex_unlock(&dev->client_lock);
 921         if (ret < 0)
 922                 kfree(entry);
 923
 924         return ret;
 925 }
 926 EXPORT_SYMBOL(adf_attachment_allow);
 927
 928 /**
 929  * adf_obj_type_str - string representation of an adf_obj_type
 930  *
 931  * @type: the object type
 932  */
 933 const char *adf_obj_type_str(enum adf_obj_type type)
 934 {
 935         switch (type) {
 936         case ADF_OBJ_OVERLAY_ENGINE:
 937                 return "overlay engine";
 938
 939         case ADF_OBJ_INTERFACE:
 940                 return "interface";
 941
 942         case ADF_OBJ_DEVICE:
 943                 return "device";
 944
 945         default:
 946                 return "unknown";
 947         }
 948 }
 949 EXPORT_SYMBOL(adf_obj_type_str);
 950
 951 /**
 952  * adf_interface_type_str - string representation of an adf_interface's type
 953  *
 954  * @intf: the interface
 955  */
 956 const char *adf_interface_type_str(struct adf_interface *intf)
 957 {
 958         switch (intf->type) {
 959         case ADF_INTF_DSI:
 960                 return "DSI";
 961
 962         case ADF_INTF_eDP:
 963                 return "eDP";
 964
 965         case ADF_INTF_DPI:
 966                 return "DPI";
 967
 968         case ADF_INTF_VGA:
 969                 return "VGA";
 970
 971         case ADF_INTF_DVI:
 972                 return "DVI";
 973
 974         case ADF_INTF_HDMI:
 975                 return "HDMI";
 976
 977         case ADF_INTF_MEMORY:
 978                 return "memory";
 979
 980         default:
 981                 if (intf->type >= ADF_INTF_TYPE_DEVICE_CUSTOM) {
 982                         if (intf->ops && intf->ops->type_str)
 983                                 return intf->ops->type_str(intf);
 984                         return "custom";
 985                 }
 986                 return "unknown";
 987         }
 988 }
 989 EXPORT_SYMBOL(adf_interface_type_str);
 990
 991 /**
 992  * adf_event_type_str - string representation of an adf_event_type
 993  *
 994  * @obj: ADF object that produced the event
 995  * @type: event type
 996  */
 997 const char *adf_event_type_str(struct adf_obj *obj, enum adf_event_type type)
 998 {
 999         switch (type) {
1000         case ADF_EVENT_VSYNC:
1001                 return "vsync";
1002
1003         case ADF_EVENT_HOTPLUG:
1004                 return "hotplug";
1005
1006         default:
1007                 if (type >= ADF_EVENT_DEVICE_CUSTOM) {
1008                         if (obj->ops && obj->ops->event_type_str)
1009                                 return obj->ops->event_type_str(obj, type);
1010                         return "custom";
1011                 }
1012                 return "unknown";
1013         }
1014 }
1015 EXPORT_SYMBOL(adf_event_type_str);
1016
1017 /**
1018  * adf_format_str - string representation of an ADF/DRM fourcc format
1019  *
1020  * @format: format fourcc
1021  * @buf: target buffer for the format's string representation
1022  */
1023 void adf_format_str(u32 format, char buf[ADF_FORMAT_STR_SIZE])
1024 {
1025         buf[0] = format & 0xFF;
1026         buf[1] = (format >> 8) & 0xFF;
1027         buf[2] = (format >> 16) & 0xFF;
1028         buf[3] = (format >> 24) & 0xFF;
1029         buf[4] = '\0';
1030 }
1031 EXPORT_SYMBOL(adf_format_str);
1032
1033 /**
1034  * adf_format_validate_yuv - validate the number and size of planes in buffers
1035  * with a custom YUV format.
1036  *
1037  * @dev: ADF device performing the validation
1038  * @buf: buffer to validate
1039  * @num_planes: expected number of planes
1040  * @hsub: expected horizontal chroma subsampling factor, in pixels
1041  * @vsub: expected vertical chroma subsampling factor, in pixels
1042  * @cpp: expected bytes per pixel for each plane (length @num_planes)
1043  *
1044  * adf_format_validate_yuv() is intended to be called as a helper from @dev's
1045  * validate_custom_format() op.
1046  *
1047  * Returns 0 if @buf has the expected number of planes and each plane
1048  * has sufficient size, or -EINVAL otherwise.
1049  */
1050 int adf_format_validate_yuv(struct adf_device *dev, struct adf_buffer *buf,
1051                 u8 num_planes, u8 hsub, u8 vsub, u8 cpp[])
1052 {
1053         u8 i;
1054
1055         if (num_planes != buf->n_planes) {
1056                 char format_str[ADF_FORMAT_STR_SIZE];
1057                 adf_format_str(buf->format, format_str);
1058                 dev_err(&dev->base.dev, "%u planes expected for format %s but %u planes provided\n",
1059                                 num_planes, format_str, buf->n_planes);
1060                 return -EINVAL;
1061         }
1062
1063         if (buf->w == 0 || buf->w % hsub) {
1064                 dev_err(&dev->base.dev, "bad buffer width %u\n", buf->w);
1065                 return -EINVAL;
1066         }
1067
1068         if (buf->h == 0 || buf->h % vsub) {
1069                 dev_err(&dev->base.dev, "bad buffer height %u\n", buf->h);
1070                 return -EINVAL;
1071         }
1072
1073         for (i = 0; i < num_planes; i++) {
1074                 u32 width = buf->w / (i != 0 ? hsub : 1);
1075                 u32 height = buf->h / (i != 0 ? vsub : 1);
1076                 u8 cpp = adf_format_plane_cpp(buf->format, i);
1077                 u32 last_line_size;
1078
1079                 if (buf->pitch[i] < (u64) width * cpp) {
1080                         dev_err(&dev->base.dev, "plane %u pitch is shorter than buffer width (pitch = %u, width = %u, bpp = %u)\n",
1081                                         i, buf->pitch[i], width, cpp * 8);
1082                         return -EINVAL;
1083                 }
1084
1085                 switch (dev->ops->quirks.buffer_padding) {
1086                 case ADF_BUFFER_PADDED_TO_PITCH:
1087                         last_line_size = buf->pitch[i];
1088                         break;
1089
1090                 case ADF_BUFFER_UNPADDED:
1091                         last_line_size = width * cpp;
1092                         break;
1093
1094                 default:
1095                         BUG();
1096                 }
1097
1098                 if ((u64) (height - 1) * buf->pitch[i] + last_line_size +
1099                                 buf->offset[i] > buf->dma_bufs[i]->size) {
1100                         dev_err(&dev->base.dev, "plane %u buffer too small (height = %u, pitch = %u, offset = %u, size = %zu)\n",
1101                                         i, height, buf->pitch[i],
1102                                         buf->offset[i], buf->dma_bufs[i]->size);
1103                         return -EINVAL;
1104                 }
1105         }
1106
1107         return 0;
1108 }
1109 EXPORT_SYMBOL(adf_format_validate_yuv);
1110
1111 /**
1112  * adf_modeinfo_set_name - sets the name of a mode from its display resolution
1113  *
1114  * @mode: mode
1115  *
1116  * adf_modeinfo_set_name() fills in @mode->name in the format
1117  * "[hdisplay]x[vdisplay](i)".  It is intended to help drivers create
1118  * ADF/DRM-style modelists from other mode formats.
1119  */
1120 void adf_modeinfo_set_name(struct drm_mode_modeinfo *mode)
1121 {
1122         bool interlaced = mode->flags & DRM_MODE_FLAG_INTERLACE;
1123
1124         snprintf(mode->name, DRM_DISPLAY_MODE_LEN, "%dx%d%s",
1125                  mode->hdisplay, mode->vdisplay,
1126                  interlaced ? "i" : "");
1127 }
1128 EXPORT_SYMBOL(adf_modeinfo_set_name);
1129
1130 /**
1131  * adf_modeinfo_set_vrefresh - sets the vrefresh of a mode from its other
1132  * timing data
1133  *
1134  * @mode: mode
1135  *
1136  * adf_modeinfo_set_vrefresh() calculates @mode->vrefresh from
1137  * @mode->{h,v}display and @mode->flags.  It is intended to help drivers
1138  * create ADF/DRM-style modelists from other mode formats.
1139  */
1140 void adf_modeinfo_set_vrefresh(struct drm_mode_modeinfo *mode)
1141 {
1142         int refresh = 0;
1143         unsigned int calc_val;
1144
1145         if (mode->vrefresh > 0)
1146                 return;
1147
1148         if (mode->htotal <= 0 || mode->vtotal <= 0)
1149                 return;
1150
1151         /* work out vrefresh the value will be x1000 */
1152         calc_val = (mode->clock * 1000);
1153         calc_val /= mode->htotal;
1154         refresh = (calc_val + mode->vtotal / 2) / mode->vtotal;
1155
1156         if (mode->flags & DRM_MODE_FLAG_INTERLACE)
1157                 refresh *= 2;
1158         if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
1159                 refresh /= 2;
1160         if (mode->vscan > 1)
1161                 refresh /= mode->vscan;
1162
1163         mode->vrefresh = refresh;
1164 }
1165 EXPORT_SYMBOL(adf_modeinfo_set_vrefresh);
1166
1167 static int __init adf_init(void)
1168 {
1169         int err;
1170
1171         err = adf_sysfs_init();
1172         if (err < 0)
1173                 return err;
1174
1175         return 0;
1176 }
1177
1178 static void __exit adf_exit(void)
1179 {
1180         adf_sysfs_destroy();
1181 }
1182
1183 module_init(adf_init);
1184 module_exit(adf_exit);