diff --git a/plugins/gstcoral.c b/plugins/gstcoral.c
index 07be7cd..7af7dea 100644
--- a/plugins/gstcoral.c
+++ b/plugins/gstcoral.c
@@ -18,6 +18,7 @@
 #include "config.h"
 #endif
 
+#include "gstionallocator.h"
 #include "gstglbox.h"
 #include "gstglsvgoverlay.h"
 
@@ -28,6 +29,16 @@
 static gboolean
 plugin_init (GstPlugin * plugin)
 {
+  GstAllocator *ion;
+
+  ion = (GstAllocator *) g_object_new (GST_TYPE_ALLOCATOR_ION, NULL);
+  gst_object_ref_sink (ion);
+  if (gst_allocator_ion_init_check (GST_ALLOCATOR_ION (ion))) {
+    gst_allocator_register (GST_ALLOCATOR_ION_NAME, ion);
+  } else {
+    /* ION allocator not supported. */
+    gst_object_unref (ion);
+  }
 
   if (!gst_element_register (plugin, "glbox",
           GST_RANK_NONE, gst_gl_box_get_type ())) {
diff --git a/plugins/gstionallocator.c b/plugins/gstionallocator.c
new file mode 100644
index 0000000..f73eed3
--- /dev/null
+++ b/plugins/gstionallocator.c
@@ -0,0 +1,175 @@
+/*
+ * # Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <sys/ioctl.h>
+
+#include "gstionallocator.h"
+#include "ion_coral.h"
+
+GST_DEBUG_CATEGORY_STATIC (ion_debug);
+#define GST_CAT_DEFAULT ion_debug
+#define gst_allocator_ion_parent_class parent_class
+G_DEFINE_TYPE (GstAllocatorIon, gst_allocator_ion, GST_TYPE_DMABUF_ALLOCATOR);
+
+static void gst_allocator_ion_finalize (GObject * object);
+static GstMemory * gst_allocator_ion_alloc (GstAllocator * allocator,
+    gsize size,GstAllocationParams * params);
+
+static void
+gst_allocator_ion_class_init (GstAllocatorIonClass * klass)
+{
+  GST_ALLOCATOR_CLASS (klass)->alloc = gst_allocator_ion_alloc;
+  G_OBJECT_CLASS (klass)->finalize = gst_allocator_ion_finalize;
+
+  GST_DEBUG_CATEGORY_INIT (ion_debug, "ion", 0,
+      "Linux dma-buf allocator based on ION");
+}
+
+static void
+gst_allocator_ion_init (GstAllocatorIon * ion)
+{
+  GstAllocator *allocator = GST_ALLOCATOR (ion);
+
+  allocator->mem_type = GST_ALLOCATOR_ION_NAME;
+
+  ion->fd = -1;
+  ion->heap_mask = -1;
+  g_mutex_init (&ion->mutex);
+}
+
+static void
+gst_allocator_ion_finalize (GObject * object)
+{
+  GstAllocatorIon *ion = GST_ALLOCATOR_ION (object);
+
+  if (ion->fd > -1) {
+    close (ion->fd);
+    ion->fd = -1;
+  }
+  g_mutex_clear (&ion->mutex);
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+gboolean
+gst_allocator_ion_init_check (GstAllocatorIon * ion)
+{
+  int fd, buf_fd, heap_mask, i;
+  gboolean success;
+  struct ion_heap_query query;
+  struct ion_allocation_data alloc_data;
+  struct ion_heap_data *heap_data = NULL;
+
+  g_mutex_lock (&ion->mutex);
+
+  fd = 1;
+  buf_fd = -1;
+  heap_mask = 0;
+  success = FALSE;
+
+  if (ion->fd > -1) {
+    GST_DEBUG_OBJECT (ion, "Already initialized");
+    goto beach;
+  }
+
+  GST_DEBUG_OBJECT (ion, "Opening /dev/ion");
+  fd = open ("/dev/ion", O_RDWR);
+  if (fd == -1) {
+    GST_INFO_OBJECT (ion, "ION allocator not supported");
+    g_mutex_unlock (&ion->mutex);
+    return FALSE;
+  }
+  GST_DEBUG_OBJECT (ion, "/dev/ion opened with fd=%d", fd);
+
+  memset (&query, 0, sizeof(query));
+  if (ioctl (fd, ION_IOC_HEAP_QUERY, &query) < 0) {
+    GST_ERROR_OBJECT (ion, "ION_IOC_HEAP_QUERY failed: %d", errno);
+    goto beach;
+  }
+
+  GST_DEBUG_OBJECT (ion, "ION_IOC_HEAP_QUERY returned %u heaps", query.cnt);
+  heap_data = g_malloc0_n (query.cnt, sizeof(*heap_data));
+  query.heaps = (uintptr_t) heap_data;
+  if (ioctl (fd, ION_IOC_HEAP_QUERY, &query) < 0) {
+    GST_ERROR_OBJECT (ion, "ION_IOC_HEAP_QUERY failed: %d", errno);
+    goto beach;
+  }
+
+  for (i = 0; i < query.cnt; ++i) {
+    if (heap_data[i].type == ION_HEAP_TYPE_DMA) {
+      heap_mask |= 1 << heap_data[i].heap_id;
+    }
+  }
+
+  memset (&alloc_data, 0, sizeof(alloc_data));
+  alloc_data.len = 42;
+  alloc_data.heap_id_mask = heap_mask;
+  alloc_data.flags = ION_FLAG_CACHED;
+
+  if (ioctl (fd, ION_IOC_ALLOC, &alloc_data) < 0) {
+    GST_ERROR_OBJECT (ion, "ION_IOC_ALLOC failed: %d", errno);
+    goto beach;
+  }
+  buf_fd = alloc_data.fd;
+
+beach:
+  success = buf_fd != -1;
+  if (success) {
+    close (buf_fd);
+    ion->fd = fd;
+    ion->heap_mask = heap_mask;
+    GST_INFO_OBJECT (ion, "ION allocator initialized");
+  } else {
+    GST_ERROR_OBJECT (ion, "ION allocator initialization failed");
+  }
+
+  g_mutex_unlock (&ion->mutex);
+
+  return success;
+}
+
+
+
+static GstMemory *
+gst_allocator_ion_alloc (GstAllocator * allocator, gsize size,
+    GstAllocationParams * params)
+{
+  GstAllocatorIon *ion = GST_ALLOCATOR_ION (allocator);
+  struct ion_allocation_data alloc_data = { 0 };
+
+  alloc_data.len = size;
+  alloc_data.heap_id_mask = ion->heap_mask;
+  alloc_data.flags = ION_FLAG_CACHED;
+
+  if (ioctl (ion->fd, ION_IOC_ALLOC, &alloc_data) < 0) {
+    GST_ERROR_OBJECT (ion, "ION_IOC_ALLOC failed: %d", errno);
+    return NULL;
+  }
+
+  GST_DEBUG_OBJECT (ion, "allocated size %" G_GSIZE_FORMAT " b, fd %d",
+      size, alloc_data.fd);
+  return gst_dmabuf_allocator_alloc (allocator, alloc_data.fd, size);
+}
+
+
+gboolean gst_allocator_ion_init_check (GstAllocatorIon * ion);
\ No newline at end of file
diff --git a/plugins/gstionallocator.h b/plugins/gstionallocator.h
new file mode 100644
index 0000000..e125d92
--- /dev/null
+++ b/plugins/gstionallocator.h
@@ -0,0 +1,50 @@
+/*
+ * # Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __ALLOCATOR_ION_H__
+#define __ALLOCATOR_ION_H__
+
+#include <gst/gst.h>
+#include <gst/allocators/gstdmabuf.h>
+
+#define GST_TYPE_ALLOCATOR_ION             (gst_allocator_ion_get_type())
+#define GST_ALLOCATOR_ION(obj)             (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_ALLOCATOR_ION, GstAllocatorIon))
+#define GST_ALLOCATOR_ION_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_ALLOCATOR_ION, GstAllocatorIonClass))
+#define GST_IS_ALLOCATOR_ION(obj)          (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_ALLOCATOR_ION))
+#define GST_IS_ALLOCATOR_ION_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_ALLOCATOR_ION))
+
+#define GST_ALLOCATOR_ION_NAME "ion"
+
+typedef struct _GstAllocatorIon GstAllocatorIon;
+typedef struct _GstAllocatorIonClass GstAllocatorIonClass;
+
+struct _GstAllocatorIon {
+  GstDmaBufAllocator parent;
+
+  GMutex mutex;
+  int fd;
+  int heap_mask;
+};
+
+struct _GstAllocatorIonClass {
+  GstDmaBufAllocatorClass parent_class;
+};
+
+GType gst_allocator_ion_get_type (void);
+
+gboolean gst_allocator_ion_init_check (GstAllocatorIon * ion);
+
+#endif
diff --git a/plugins/ion_coral.h b/plugins/ion_coral.h
new file mode 100644
index 0000000..8f765af
--- /dev/null
+++ b/plugins/ion_coral.h
@@ -0,0 +1,126 @@
+/*
+ * drivers/staging/android/uapi/ion.h
+ *
+ * Copyright (C) 2011 Google, Inc.
+ */
+
+#ifndef _UAPI_LINUX_ION_H
+#define _UAPI_LINUX_ION_H
+
+#include <linux/ioctl.h>
+#include <linux/types.h>
+
+/**
+ * enum ion_heap_types - list of all possible types of heaps
+ * @ION_HEAP_TYPE_SYSTEM:	 memory allocated via vmalloc
+ * @ION_HEAP_TYPE_SYSTEM_CONTIG: memory allocated via kmalloc
+ * @ION_HEAP_TYPE_CARVEOUT:	 memory allocated from a prereserved
+ *				 carveout heap, allocations are physically
+ *				 contiguous
+ * @ION_HEAP_TYPE_DMA:		 memory allocated via DMA API
+ * @ION_NUM_HEAPS:		 helper for iterating over heaps, a bit mask
+ *				 is used to identify the heaps, so only 32
+ *				 total heap types are supported
+ */
+enum ion_heap_type {
+	ION_HEAP_TYPE_SYSTEM,
+	ION_HEAP_TYPE_SYSTEM_CONTIG,
+	ION_HEAP_TYPE_CARVEOUT,
+	ION_HEAP_TYPE_CHUNK,
+	ION_HEAP_TYPE_DMA,
+	ION_HEAP_TYPE_CUSTOM, /*
+			       * must be last so device specific heaps always
+			       * are at the end of this enum
+			       */
+};
+
+#define ION_NUM_HEAP_IDS		(sizeof(unsigned int) * 8)
+
+/**
+ * allocation flags - the lower 16 bits are used by core ion, the upper 16
+ * bits are reserved for use by the heaps themselves.
+ */
+
+/*
+ * mappings of this buffer should be cached, ion will do cache maintenance
+ * when the buffer is mapped for dma
+ */
+#define ION_FLAG_CACHED 1
+
+/**
+ * DOC: Ion Userspace API
+ *
+ * create a client by opening /dev/ion
+ * most operations handled via following ioctls
+ *
+ */
+
+/**
+ * struct ion_allocation_data - metadata passed from userspace for allocations
+ * @len:		size of the allocation
+ * @heap_id_mask:	mask of heap ids to allocate from
+ * @flags:		flags passed to heap
+ * @handle:		pointer that will be populated with a cookie to use to
+ *			refer to this allocation
+ *
+ * Provided by userspace as an argument to the ioctl
+ */
+struct ion_allocation_data {
+	__u64 len;
+	__u32 heap_id_mask;
+	__u32 flags;
+	__u32 fd;
+	__u32 unused;
+};
+
+#define MAX_HEAP_NAME			32
+
+/**
+ * struct ion_heap_data - data about a heap
+ * @name - first 32 characters of the heap name
+ * @type - heap type
+ * @heap_id - heap id for the heap
+ */
+struct ion_heap_data {
+	char name[MAX_HEAP_NAME];
+	__u32 type;
+	__u32 heap_id;
+	__u32 reserved0;
+	__u32 reserved1;
+	__u32 reserved2;
+};
+
+/**
+ * struct ion_heap_query - collection of data about all heaps
+ * @cnt - total number of heaps to be copied
+ * @heaps - buffer to copy heap data
+ */
+struct ion_heap_query {
+	__u32 cnt; /* Total number of heaps to be copied */
+	__u32 reserved0; /* align to 64bits */
+	__u64 heaps; /* buffer to be populated */
+	__u32 reserved1;
+	__u32 reserved2;
+};
+
+#define ION_IOC_MAGIC		'I'
+
+/**
+ * DOC: ION_IOC_ALLOC - allocate memory
+ *
+ * Takes an ion_allocation_data struct and returns it with the handle field
+ * populated with the opaque handle for the allocation.
+ */
+#define ION_IOC_ALLOC		_IOWR(ION_IOC_MAGIC, 0, \
+				      struct ion_allocation_data)
+
+/**
+ * DOC: ION_IOC_HEAP_QUERY - information about available heaps
+ *
+ * Takes an ion_heap_query structure and populates information about
+ * available Ion heaps.
+ */
+#define ION_IOC_HEAP_QUERY     _IOWR(ION_IOC_MAGIC, 8, \
+					struct ion_heap_query)
+
+#endif /* _UAPI_LINUX_ION_H */