WebSVN – Kolibri OS – Diff – /drivers/video/drm/ttm/ttm_object.c

 /**************************************************************************
+ *
- * Copyright (c) 2009 VMware, Inc., Palo Alto, CA., USA
+ * Copyright (c) 2009-2013 VMware, Inc., Palo Alto, CA., USA
  * All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the
  * "Software"), to deal in the Software without restriction, including
  * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
  **************************************************************************/
 /*
  * Authors: Thomas Hellstrom
+ *
+ * While no substantial code is shared, the prime code is inspired by
+ * drm_prime.c, with
+ * Authors:
+ *      Dave Airlie
+ *      Rob Clark
  */
 /** @file ttm_ref_object.c
+ *
  * Base- and reference object implementation for the various
  * ttm objects. Implements reference counting, minimal security checks
  * and release on file close.
  */
 /**
  * struct ttm_object_file
+ *
  * @tdev: Pointer to the ttm_object_device.
  * for fast lookup of ref objects given a base object.
  */
+#define pr_fmt(fmt) "[TTM] " fmt
-#define pr_fmt(fmt) "[TTM] " fmt
+#include
 #include
 #include
 #include
 #define pr_err(fmt, ...) \
         printk(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__)
 struct ttm_object_file {
 	struct ttm_object_device *tdev;
-	rwlock_t lock;
+	spinlock_t lock;
 	struct list_head ref_list;
 	struct drm_open_hash ref_hash[TTM_REF_NUM];
 	struct kref refcount;
 	enum ttm_ref_type ref_type;
 	struct ttm_base_object *obj;
 	struct ttm_object_file *tfile;
 };
+static void ttm_prime_dmabuf_release(struct dma_buf *dma_buf);
 static inline struct ttm_object_file *
 ttm_object_file_ref(struct ttm_object_file *tfile)
+{
 	kref_get(&tfile->refcount);
 	 * Note: We don't use synchronize_rcu() here because it's far
 	 * too slow. It's up to the user to free the object using
 	 * call_rcu() or ttm_base_object_kfree().
 	 */
 	if (base->refcount_release) {
+	ttm_object_file_unref(&base->tfile);
-		ttm_object_file_unref(&base->tfile);
+	if (base->refcount_release)
 		base->refcount_release(&base);
-	}
+}
 void ttm_base_object_unref(struct ttm_base_object **p_base)
 EXPORT_SYMBOL(ttm_base_object_unref);
 struct ttm_base_object *ttm_base_object_lookup(struct ttm_object_file *tfile,
 					       uint32_t key)
-{
-	struct ttm_object_device *tdev = tfile->tdev;
+{
-	struct ttm_base_object *base;
+	struct ttm_base_object *base = NULL;
+	struct drm_hash_item *hash;
-	struct drm_hash_item *hash;
+	struct drm_open_hash *ht = &tfile->ref_hash[TTM_REF_USAGE];
 	int ret;
-//   rcu_read_lock();
+//	rcu_read_lock();
-	ret = drm_ht_find_item_rcu(&tdev->object_hash, key, &hash);
+	ret = drm_ht_find_item_rcu(ht, key, &hash);
+	if (likely(ret == 0)) {
-	if (likely(ret == 0)) {
+		base = drm_hash_entry(hash, struct ttm_ref_object, hash)->obj;
-		base = drm_hash_entry(hash, struct ttm_base_object, hash);
+		if (!kref_get_unless_zero(&base->refcount))
-		ret = kref_get_unless_zero(&base->refcount) ? 0 : -EINVAL;
-	}
+			base = NULL;
+	}
+//   rcu_read_unlock();
+	return base;
+}
-//   rcu_read_unlock();
+EXPORT_SYMBOL(ttm_base_object_lookup);
+struct ttm_base_object *
+ttm_base_object_lookup_for_ref(struct ttm_object_device *tdev, uint32_t key)
+{
+	struct ttm_base_object *base = NULL;
+	struct drm_hash_item *hash;
+	struct drm_open_hash *ht = &tdev->object_hash;
+	int ret;
-	if (unlikely(ret != 0))
-		return NULL;
+	ret = drm_ht_find_item_rcu(ht, key, &hash);
-	if (tfile != base->tfile && !base->shareable) {
+	if (likely(ret == 0)) {
-		pr_err("Attempted access of non-shareable object\n");
+		base = drm_hash_entry(hash, struct ttm_base_object, hash);
-		ttm_base_object_unref(&base);
+		if (!kref_get_unless_zero(&base->refcount))
-		return NULL;
+			base = NULL;
+	}
 	return base;
 	if (existed != NULL)
 		*existed = true;
-	while (ret == -EINVAL) {
-		read_lock(&tfile->lock);
+	while (ret == -EINVAL) {
-		ret = drm_ht_find_item(ht, base->hash.key, &hash);
+		ret = drm_ht_find_item_rcu(ht, base->hash.key, &hash);
-		if (ret == 0) {
-			ref = drm_hash_entry(hash, struct ttm_ref_object, hash);
+		if (ret == 0) {
-			kref_get(&ref->kref);
+			ref = drm_hash_entry(hash, struct ttm_ref_object, hash);
+			if (!kref_get_unless_zero(&ref->kref)) {
-			read_unlock(&tfile->lock);
 			break;
+		}
+		}
 		read_unlock(&tfile->lock);
 		ret = ttm_mem_global_alloc(mem_glob, sizeof(*ref),
 		ref->obj = base;
 		ref->tfile = tfile;
 		ref->ref_type = ref_type;
 		kref_init(&ref->kref);
-		write_lock(&tfile->lock);
+		spin_lock(&tfile->lock);
-		ret = drm_ht_insert_item(ht, &ref->hash);
+		ret = drm_ht_insert_item_rcu(ht, &ref->hash);
 		if (likely(ret == 0)) {
 			list_add_tail(&ref->head, &tfile->ref_list);
 			kref_get(&base->refcount);
-			write_unlock(&tfile->lock);
+			spin_unlock(&tfile->lock);
 			if (existed != NULL)
 				*existed = false;
 			break;
+		}
-		write_unlock(&tfile->lock);
+		spin_unlock(&tfile->lock);
 		BUG_ON(ret != -EINVAL);
 	struct ttm_object_file *tfile = ref->tfile;
 	struct drm_open_hash *ht;
 	struct ttm_mem_global *mem_glob = tfile->tdev->mem_glob;
 	ht = &tfile->ref_hash[ref->ref_type];
-	(void)drm_ht_remove_item(ht, &ref->hash);
+	(void)drm_ht_remove_item_rcu(ht, &ref->hash);
 	list_del(&ref->head);
-	write_unlock(&tfile->lock);
+	spin_unlock(&tfile->lock);
 	if (ref->ref_type != TTM_REF_USAGE && base->ref_obj_release)
 		base->ref_obj_release(base, ref->ref_type);
 	ttm_base_object_unref(&ref->obj);
 	ttm_mem_global_free(mem_glob, sizeof(*ref));
 	kfree(ref);
-	write_lock(&tfile->lock);
+	spin_lock(&tfile->lock);
+}
 int ttm_ref_object_base_unref(struct ttm_object_file *tfile,
 			      unsigned long key, enum ttm_ref_type ref_type)
+{
 	struct drm_open_hash *ht = &tfile->ref_hash[ref_type];
 	struct ttm_ref_object *ref;
 	struct drm_hash_item *hash;
 	int ret;
-	write_lock(&tfile->lock);
+	spin_lock(&tfile->lock);
 	ret = drm_ht_find_item(ht, key, &hash);
 	if (unlikely(ret != 0)) {
-		write_unlock(&tfile->lock);
+		spin_unlock(&tfile->lock);
 		return -EINVAL;
+	}
 	ref = drm_hash_entry(hash, struct ttm_ref_object, hash);
 	kref_put(&ref->kref, ttm_ref_object_release);
 	struct list_head *list;
 	unsigned int i;
 	struct ttm_object_file *tfile = *p_tfile;
 	*p_tfile = NULL;
-	write_lock(&tfile->lock);
+	spin_lock(&tfile->lock);
 	/*
 	 * Since we release the lock within the loop, we have to
+	}
 	for (i = 0; i < TTM_REF_NUM; ++i)
 		drm_ht_remove(&tfile->ref_hash[i]);
-	write_unlock(&tfile->lock);
+	spin_unlock(&tfile->lock);
 	ttm_object_file_unref(&tfile);
+}
 	int ret;
 	if (unlikely(tfile == NULL))
 		return NULL;
-	rwlock_init(&tfile->lock);
+	spin_lock_init(&tfile->lock);
 	tfile->tdev = tdev;
 	kref_init(&tfile->refcount);
 	return NULL;
+}
 EXPORT_SYMBOL(ttm_object_file_init);
-struct ttm_object_device *ttm_object_device_init(struct ttm_mem_global
+struct ttm_object_device *
+ttm_object_device_init(struct ttm_mem_global *mem_glob,
-						 *mem_glob,
+		       unsigned int hash_order,
-						 unsigned int hash_order)
+		       const struct dma_buf_ops *ops)
+{
 	struct ttm_object_device *tdev = kmalloc(sizeof(*tdev), GFP_KERNEL);
 	tdev->mem_glob = mem_glob;
 	spin_lock_init(&tdev->object_lock);
 	atomic_set(&tdev->object_count, 0);
+	ret = drm_ht_create(&tdev->object_hash, hash_order);
+	if (ret != 0)
-	ret = drm_ht_create(&tdev->object_hash, hash_order);
+		goto out_no_object_hash;
+//   tdev->ops = *ops;
+//   tdev->dmabuf_release = tdev->ops.release;
+//   tdev->ops.release = ttm_prime_dmabuf_release;
 //   tdev->dma_buf_size = ttm_round_pot(sizeof(struct dma_buf)) +
+//       ttm_round_pot(sizeof(struct file));
-	if (likely(ret == 0))
+		return tdev;
 		return tdev;
 out_no_object_hash:
 	kfree(tdev);

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/ttm/ttm_object.c – Rev 4075 → 4569