index bc9b0e13eee971347a34a66f994d83f4b670bf03..afb7f93a39adcecf1204c79da07982e685910de9 100644 (file)
uint32_t read_pending;
uint32_t read_complete;
} *sync;
+
+ struct omap_gem_vm_ops *ops;
+
+ /**
+ * per-mapper private data..
+ *
+ * TODO maybe there can be a more flexible way to store per-mapper
+ * data.. for now I just keep it simple, and since this is only
+ * accessible externally via omap_gem_priv()/omap_get_set_priv()
+ */
+ void *priv[MAX_MAPPERS];
+
};
static int get_pages(struct drm_gem_object *obj, struct page ***pages);
{
return to_omap_bo(obj)->flags;
}
+EXPORT_SYMBOL(omap_gem_flags);
/** get mmap offset */
static uint64_t mmap_offset(struct drm_gem_object *obj)
mutex_unlock(&obj->dev->struct_mutex);
return offset;
}
+EXPORT_SYMBOL(omap_gem_mmap_offset);
/** get mmap size */
size_t omap_gem_mmap_size(struct drm_gem_object *obj)
}
return -EINVAL;
}
+EXPORT_SYMBOL(omap_gem_tiled_size);
/* Normal handling for the case of faulting in non-tiled buffers */
static int fault_1d(struct drm_gem_object *obj,
vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
}
+ if (omap_obj->ops && omap_obj->ops->mmap)
+ omap_obj->ops->mmap(obj->filp, vma);
+
return 0;
}
return ret;
}
+EXPORT_SYMBOL(omap_gem_get_paddr);
/* Release physical address, when DMA is no longer being performed.. this
* could potentially unpin and unmap buffers from TILER
mutex_unlock(&obj->dev->struct_mutex);
}
+EXPORT_SYMBOL(omap_gem_put_paddr);
/* Get rotated scanout address (only valid if already pinned), at the
* specified orientation and x,y offset from top-left corner of buffer
ret = tiler_stride(gem2fmt(omap_obj->flags), orient);
return ret;
}
+EXPORT_SYMBOL(omap_gem_tiled_stride);
/* acquire pages when needed (for example, for DMA where physically
* contiguous buffer is not required
mutex_unlock(&obj->dev->struct_mutex);
return ret;
}
+EXPORT_SYMBOL(omap_gem_get_pages);
/* release pages when DMA no longer being performed */
int omap_gem_put_pages(struct drm_gem_object *obj)
*/
return 0;
}
+EXPORT_SYMBOL(omap_gem_put_pages);
/* Get kernel virtual address for CPU access.. this more or less only
* exists for omap_fbdev. This should be called with struct_mutex
static void sync_op_update(void)
{
+ LIST_HEAD(call_list);
+
struct omap_gem_sync_waiter *waiter, *n;
list_for_each_entry_safe(waiter, n, &waiters, list) {
if (!is_waiting(waiter)) {
list_del(&waiter->list);
- SYNC("notify: %p", waiter);
- waiter->notify(waiter->arg);
- kfree(waiter);
+ list_add(&waiter->list, &call_list);
}
}
+
+ spin_unlock(&sync_lock);
+
+ list_for_each_entry_safe(waiter, n, &call_list, list) {
+ SYNC("notify: %p", waiter);
+ list_del(&waiter->list);
+ waiter->notify(waiter->arg);
+ kfree(waiter);
+ }
+
+ spin_lock(&sync_lock);
}
static inline int sync_op(struct drm_gem_object *obj,
sync_op_update();
spin_unlock(&sync_lock);
}
+EXPORT_SYMBOL(omap_gem_op_update);
/* mark the start of read and/or write operation */
int omap_gem_op_start(struct drm_gem_object *obj, enum omap_gem_op op)
{
return sync_op(obj, op, true);
}
+EXPORT_SYMBOL(omap_gem_op_start);
int omap_gem_op_finish(struct drm_gem_object *obj, enum omap_gem_op op)
{
return sync_op(obj, op, false);
}
+EXPORT_SYMBOL(omap_gem_op_finish);
static DECLARE_WAIT_QUEUE_HEAD(sync_event);
SYNC("waited: %p", waiter);
list_add_tail(&waiter->list, &waiters);
spin_unlock(&sync_lock);
- ret = wait_event_interruptible(sync_event,
- (waiter_task == NULL));
+ wait_event(sync_event, (waiter_task == NULL));
spin_lock(&sync_lock);
- if (waiter_task) {
- SYNC("interrupted: %p", waiter);
- /* we were interrupted */
- list_del(&waiter->list);
- waiter_task = NULL;
- } else {
- /* freed in sync_op_update() */
- waiter = NULL;
- }
+ waiter = NULL;
}
spin_unlock(&sync_lock);
}
return ret;
}
+EXPORT_SYMBOL(omap_gem_op_sync);
/* call fxn(arg), either synchronously or asynchronously if the op
* is currently blocked.. fxn() can be called from any context
return 0;
}
+EXPORT_SYMBOL(omap_gem_op_async);
/* special API so PVR can update the buffer to use a sync-object allocated
* from it's sync-obj heap. Only used for a newly allocated (from PVR's
spin_unlock(&sync_lock);
return ret;
}
+EXPORT_SYMBOL(omap_gem_set_sync_object);
/* don't call directly.. called from GEM core when it is time to actually
* free the object..
drm_gem_object_release(obj);
- kfree(obj);
+ kfree(omap_obj);
}
/* convenience method to construct a GEM buffer object, and userspace handle */
ret = drm_gem_handle_create(file, obj, handle);
if (ret) {
+ struct omap_gem_object *omap_obj = to_omap_bo(obj);
drm_gem_object_release(obj);
- kfree(obj); /* TODO isn't there a dtor to call? just copying i915 */
+ kfree(omap_obj); /* TODO isn't there a dtor to call? just copying i915 */
return ret;
}
*/
kfree(usergart);
}
+
+/****** PLUGIN API specific ******/
+
+/* This constructor is mainly to give plugins a way to wrap their
+ * own allocations
+ */
+struct drm_gem_object *omap_gem_new_ext(struct drm_device *dev,
+ union omap_gem_size gsize, uint32_t flags,
+ dma_addr_t paddr, struct page **pages,
+ struct omap_gem_vm_ops *ops)
+{
+ struct drm_gem_object *obj;
+
+ BUG_ON((flags & OMAP_BO_TILED) && !pages);
+
+ if (paddr)
+ flags |= OMAP_BO_DMA;
+
+ obj = omap_gem_new(dev, gsize, flags | OMAP_BO_EXT_MEM);
+ if (obj) {
+ struct omap_gem_object *omap_obj = to_omap_bo(obj);
+ omap_obj->paddr = paddr;
+ omap_obj->pages = pages;
+ omap_obj->ops = ops;
+ }
+ return obj;
+}
+EXPORT_SYMBOL(omap_gem_new_ext);
+
+void omap_gem_vm_open(struct vm_area_struct *vma)
+{
+ struct drm_gem_object *obj = vma->vm_private_data;
+ struct omap_gem_object *omap_obj = to_omap_bo(obj);
+
+ if (omap_obj->ops && omap_obj->ops->open)
+ omap_obj->ops->open(vma);
+ else
+ drm_gem_vm_open(vma);
+
+}
+
+void omap_gem_vm_close(struct vm_area_struct *vma)
+{
+ struct drm_gem_object *obj = vma->vm_private_data;
+ struct omap_gem_object *omap_obj = to_omap_bo(obj);
+
+ if (omap_obj->ops && omap_obj->ops->close)
+ omap_obj->ops->close(vma);
+ else
+ drm_gem_vm_close(vma);
+
+}
+
+void *omap_gem_priv(struct drm_gem_object *obj, int mapper_id)
+{
+ BUG_ON((mapper_id >= MAX_MAPPERS) || (mapper_id < 0));
+ return to_omap_bo(obj)->priv[mapper_id];
+}
+EXPORT_SYMBOL(omap_gem_priv);
+
+void omap_gem_set_priv(struct drm_gem_object *obj, int mapper_id, void *priv)
+{
+ BUG_ON((mapper_id >= MAX_MAPPERS) || (mapper_id < 0));
+ to_omap_bo(obj)->priv[mapper_id] = priv;
+}
+EXPORT_SYMBOL(omap_gem_set_priv);