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