aboutsummaryrefslogtreecommitdiff
path: root/drivers/mfd
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/mfd')
-rw-r--r--drivers/mfd/glamo/Kconfig9
-rw-r--r--drivers/mfd/glamo/Makefile5
-rw-r--r--drivers/mfd/glamo/glamo-buffer.c198
-rw-r--r--drivers/mfd/glamo/glamo-buffer.h57
-rw-r--r--drivers/mfd/glamo/glamo-cmdq.c421
-rw-r--r--drivers/mfd/glamo/glamo-cmdq.h41
-rw-r--r--drivers/mfd/glamo/glamo-core.c158
-rw-r--r--drivers/mfd/glamo/glamo-core.h38
-rw-r--r--drivers/mfd/glamo/glamo-drm-drv.c350
-rw-r--r--drivers/mfd/glamo/glamo-drm-private.h74
-rw-r--r--drivers/mfd/glamo/glamo-fb.c8
-rw-r--r--drivers/mfd/glamo/glamo-mci.c8
-rw-r--r--drivers/mfd/glamo/glamo-regs.h13
13 files changed, 1254 insertions, 126 deletions
diff --git a/drivers/mfd/glamo/Kconfig b/drivers/mfd/glamo/Kconfig
index efa16990d57..9c5b11b8372 100644
--- a/drivers/mfd/glamo/Kconfig
+++ b/drivers/mfd/glamo/Kconfig
@@ -57,3 +57,12 @@ config MFD_GLAMO_MCI
neo1973 GTA-02.
If unsure, say N.
+
+config MFD_GLAMO_DRM
+ tristate "Glamo DRM support"
+ depends on MFD_GLAMO && DRM
+ help
+ Direct Rendering Manager interface for the S-Media GLAMO chip, as
+ used in Openmoko neo1973 GTA-02.
+
+ If unsure, say N.
diff --git a/drivers/mfd/glamo/Makefile b/drivers/mfd/glamo/Makefile
index dc64d50fa13..75476de5ad7 100644
--- a/drivers/mfd/glamo/Makefile
+++ b/drivers/mfd/glamo/Makefile
@@ -1,7 +1,8 @@
#
-# Makefile for the Smedia Glamo framebuffer driver
+# Makefile for the Smedia Glamo driver(s)
#
+
obj-$(CONFIG_MFD_GLAMO) += glamo-core.o glamo-gpio.o
obj-$(CONFIG_MFD_GLAMO_SPI) += glamo-spi.o
obj-$(CONFIG_MFD_GLAMO_SPI_GPIO) += glamo-spi-gpio.o
@@ -9,4 +10,6 @@ obj-$(CONFIG_MFD_GLAMO_SPI_GPIO) += glamo-spi-gpio.o
obj-$(CONFIG_MFD_GLAMO_FB) += glamo-fb.o
obj-$(CONFIG_MFD_GLAMO_SPI_FB) += glamo-lcm-spi.o
obj-$(CONFIG_MFD_GLAMO_MCI) += glamo-mci.o
+obj-$(CONFIG_MFD_GLAMO_DRM) += glamo-drm.o
+glamo-drm-objs := glamo-drm-drv.o glamo-cmdq.o glamo-buffer.o
diff --git a/drivers/mfd/glamo/glamo-buffer.c b/drivers/mfd/glamo/glamo-buffer.c
new file mode 100644
index 00000000000..945824a1b15
--- /dev/null
+++ b/drivers/mfd/glamo/glamo-buffer.c
@@ -0,0 +1,198 @@
+/*
+ * SMedia Glamo 336x/337x memory management
+ *
+ * Copyright (c) 2009 Thomas White <taw@bitwiz.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ *
+ */
+
+
+#include <drm/drmP.h>
+#include <drm/glamo_drm.h>
+
+#include "glamo-drm-private.h"
+
+
+int glamo_ioctl_gem_create(struct drm_device *dev, void *data,
+ struct drm_file *file_priv)
+{
+ struct drm_glamo_gem_create *args = data;
+ struct drm_gem_object *obj;
+ struct glamodrm_handle *gdrm;
+ struct drm_glamo_gem_object *gobj;
+ int handle, ret;
+
+ gdrm = dev->dev_private;
+
+ args->size = roundup(args->size, PAGE_SIZE);
+
+ obj = drm_gem_object_alloc(dev, args->size);
+ if (obj == NULL) return -ENOMEM;
+
+ gobj = obj->driver_private;
+
+ /* Allocate memory for this object in VRAM */
+ gobj->block = drm_mm_search_free(gdrm->mmgr, args->size,
+ args->alignment, 1);
+ if (!gobj->block) {
+ ret = -ENOMEM;
+ goto fail;
+ }
+ gobj->block = drm_mm_get_block(gobj->block, args->size,
+ args->alignment);
+ if (!gobj->block) {
+ ret = -ENOMEM;
+ goto fail;
+ }
+
+ ret = drm_gem_handle_create(file_priv, obj, &handle);
+ mutex_lock(&dev->struct_mutex);
+ drm_gem_object_handle_unreference(obj);
+ mutex_unlock(&dev->struct_mutex);
+
+ if (ret) goto fail;
+
+ printk(KERN_INFO "[glamo-drm] GEM object %i: %li bytes at 0x%lx\n",
+ handle, gobj->block->size, gobj->block->start);
+ args->handle = handle;
+
+ return 0;
+
+fail:
+ mutex_lock(&dev->struct_mutex);
+ drm_gem_object_unreference(obj);
+ mutex_unlock(&dev->struct_mutex);
+ printk(KERN_INFO "[glamo-drm] Failed to allocate object\n");
+
+ return ret;
+}
+
+
+int glamo_ioctl_gem_mmap(struct drm_device *dev, void *data,
+ struct drm_file *file_priv)
+{
+ struct drm_glamo_gem_mmap *args = data;
+ struct drm_gem_object *obj;
+ loff_t offset;
+ unsigned long addr;
+
+ obj = drm_gem_object_lookup(dev, file_priv, args->handle);
+ if (obj == NULL)
+ return -EBADF;
+
+ offset = args->offset;
+
+ down_write(&current->mm->mmap_sem);
+ addr = do_mmap(obj->filp, 0, args->size,
+ PROT_READ | PROT_WRITE, MAP_SHARED,
+ args->offset);
+ up_write(&current->mm->mmap_sem);
+ mutex_lock(&dev->struct_mutex);
+ drm_gem_object_unreference(obj);
+ mutex_unlock(&dev->struct_mutex);
+ if (IS_ERR((void *)addr))
+ return addr;
+
+ args->addr_ptr = (uint64_t) addr;
+
+ return 0;
+}
+
+
+int glamo_ioctl_gem_pin(struct drm_device *dev, void *data,
+ struct drm_file *file_priv)
+{
+ printk(KERN_INFO "glamo_ioctl_gem_pin\n");
+ return 0;
+}
+
+
+int glamo_ioctl_gem_unpin(struct drm_device *dev, void *data,
+ struct drm_file *file_priv)
+{
+ printk(KERN_INFO "glamo_ioctl_gem_unpin\n");
+ return 0;
+}
+
+
+int glamo_ioctl_gem_pread(struct drm_device *dev, void *data,
+ struct drm_file *file_priv)
+{
+ printk(KERN_INFO "glamo_ioctl_gem_pread\n");
+ return 0;
+}
+
+
+int glamo_ioctl_gem_pwrite(struct drm_device *dev, void *data,
+ struct drm_file *file_priv)
+{
+ printk(KERN_INFO "glamo_ioctl_gem_pwrite\n");
+ return 0;
+}
+
+
+int glamodrm_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
+{
+ return VM_FAULT_SIGBUS;
+}
+
+
+int glamodrm_gem_init_object(struct drm_gem_object *obj)
+{
+ struct drm_glamo_gem_object *gobj;
+
+ /* Allocate a private structure */
+ gobj = drm_calloc(1, sizeof(*gobj), DRM_MEM_DRIVER);
+ if (!gobj) return -ENOMEM;
+
+ obj->driver_private = gobj;
+ gobj->obj = obj;
+
+ return 0;
+}
+
+
+void glamodrm_gem_free_object(struct drm_gem_object *obj)
+{
+ struct drm_glamo_gem_object *gobj;
+
+ gobj = obj->driver_private;
+
+ /* Free the VRAM */
+ drm_mm_put_block(gobj->block);
+
+ /* Free the private structure */
+ drm_free(obj->driver_private, 1, DRM_MEM_DRIVER);
+}
+
+
+/* Memory management initialisation */
+int glamo_buffer_init(struct glamodrm_handle *gdrm)
+{
+ gdrm->mmgr = drm_calloc(1, sizeof(struct drm_mm), DRM_MEM_DRIVER);
+ drm_mm_init(gdrm->mmgr, 0, gdrm->vram_size);
+ return 0;
+}
+
+
+/* Memory management finalisation */
+int glamo_buffer_final(struct glamodrm_handle *gdrm)
+{
+ drm_mm_takedown(gdrm->mmgr);
+ drm_free(gdrm->mmgr , 1, DRM_MEM_DRIVER);
+ return 0;
+}
diff --git a/drivers/mfd/glamo/glamo-buffer.h b/drivers/mfd/glamo/glamo-buffer.h
new file mode 100644
index 00000000000..7d87e428d79
--- /dev/null
+++ b/drivers/mfd/glamo/glamo-buffer.h
@@ -0,0 +1,57 @@
+/*
+ * SMedia Glamo 336x/337x memory management
+ *
+ * Copyright (c) 2009 Thomas White <taw@bitwiz.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ *
+ */
+
+#ifndef __GLAMO_BUFFER_H
+#define __GLAMO_BUFFER_H
+
+#include <drm/drmP.h>
+
+#include "glamo-drm-private.h"
+
+extern int glamo_buffer_init(struct glamodrm_handle *gdrm);
+extern int glamo_buffer_final(struct glamodrm_handle *gdrm);
+
+extern int glamodrm_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf);
+
+extern int glamodrm_gem_init_object(struct drm_gem_object *obj);
+
+extern void glamodrm_gem_free_object(struct drm_gem_object *obj);
+
+extern int glamo_ioctl_gem_create(struct drm_device *dev, void *data,
+ struct drm_file *file_priv);
+
+extern int glamo_ioctl_gem_mmap(struct drm_device *dev, void *data,
+ struct drm_file *file_priv);
+
+extern int glamo_ioctl_gem_pin(struct drm_device *dev, void *data,
+ struct drm_file *file_priv);
+
+extern int glamo_ioctl_gem_unpin(struct drm_device *dev, void *data,
+ struct drm_file *file_priv);
+
+extern int glamo_ioctl_gem_pread(struct drm_device *dev, void *data,
+ struct drm_file *file_priv);
+
+extern int glamo_ioctl_gem_pwrite(struct drm_device *dev, void *data,
+ struct drm_file *file_priv);
+
+#endif /* __GLAMO_BUFFER_H */
diff --git a/drivers/mfd/glamo/glamo-cmdq.c b/drivers/mfd/glamo/glamo-cmdq.c
new file mode 100644
index 00000000000..32fad98be8a
--- /dev/null
+++ b/drivers/mfd/glamo/glamo-cmdq.c
@@ -0,0 +1,421 @@
+/*
+ * SMedia Glamo 336x/337x command queue handling
+ *
+ * Copyright (C) 2008-2009 Thomas White <taw@bitwiz.org.uk>
+ * Copyright (C) 2009 Andreas Pokorny <andreas.pokorny@gmail.com>
+ * Based on xf86-video-glamo (see below for details)
+ *
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ *
+ * Command queue handling functions based on those from xf86-video-glamo, to
+ * which the following licence applies:
+ *
+ * Copyright 2007 OpenMoko, Inc.
+ * Copyright © 2009 Lars-Peter Clausen <lars@metafoo.de>
+ *
+ * This driver is based on Xati,
+ * Copyright 2004 Eric Anholt
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission. The copyright holders make no representations
+ * about the suitability of this software for any purpose. It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+#include <drm/drmP.h>
+#include <drm/glamo_drm.h>
+
+#include "glamo-core.h"
+#include "glamo-drm-private.h"
+#include "glamo-regs.h"
+
+
+static inline void reg_write(struct glamodrm_handle *gdrm,
+ u_int16_t reg, u_int16_t val)
+{
+ iowrite16(val, gdrm->reg_base + reg);
+}
+
+
+static inline u16 reg_read(struct glamodrm_handle *gdrm, u_int16_t reg)
+{
+ return ioread16(gdrm->reg_base + reg);
+}
+
+static u32 glamo_get_read(struct glamodrm_handle *gdrm)
+{
+ /* we could turn off clock here */
+ u32 ring_read = reg_read(gdrm, GLAMO_REG_CMDQ_READ_ADDRL);
+ ring_read |= ((reg_read(gdrm, GLAMO_REG_CMDQ_READ_ADDRH)
+ & 0x7) << 16);
+
+ return ring_read;
+}
+
+static u32 glamo_get_write(struct glamodrm_handle *gdrm)
+{
+ u32 ring_write = reg_read(gdrm, GLAMO_REG_CMDQ_WRITE_ADDRL);
+ ring_write |= ((reg_read(gdrm, GLAMO_REG_CMDQ_WRITE_ADDRH)
+ & 0x7) << 16);
+
+ return ring_write;
+}
+
+#if 0
+
+/* hopefully we will never need that again */
+
+static void
+glamo_cmdq_wait(struct glamodrm_handle *gdrm, enum glamo_engine engine)
+{
+ u16 mask, val, status;
+ int i;
+
+ switch (engine)
+ {
+ case GLAMO_ENGINE_CMDQ:
+ mask = 0x3;
+ val = mask;
+ break;
+ case GLAMO_ENGINE_ISP:
+ mask = 0x3 | (1 << 8);
+ val = 0x3;
+ break;
+ case GLAMO_ENGINE_2D:
+ mask = 0x3 | (1 << 4);
+ val = 0x3;
+ break;
+ case GLAMO_ENGINE_3D:
+ mask = 0x3 | (1 << 5);
+ val = 0x3;
+ break;
+ case GLAMO_ENGINE_ALL:
+ default:
+ mask = 1 << 2;
+ val = mask;
+ break;
+ }
+
+ for ( i=0; i<1000; i++ ) {
+ status = reg_read(gdrm, GLAMO_REG_CMDQ_STATUS);
+ if ((status & mask) == val) break;
+ mdelay(1);
+ }
+ if ( i == 1000 ) {
+ size_t ring_read;
+ printk(KERN_WARNING "[glamo-drm] CmdQ timeout!\n");
+ printk(KERN_WARNING "[glamo-drm] status = %x\n", status);
+ ring_read = reg_read(gdrm, GLAMO_REG_CMDQ_READ_ADDRL);
+ ring_read |= ((reg_read(gdrm, GLAMO_REG_CMDQ_READ_ADDRH)
+ & 0x7) << 16);
+ printk(KERN_INFO "[glamo-drm] ring_read now 0x%x\n",
+ ring_read);
+ }
+}
+#endif
+
+
+/* Add commands to the ring buffer */
+static int glamo_add_to_ring(struct glamodrm_handle *gdrm, u16 *addr,
+ unsigned int count)
+{
+ size_t ring_write, ring_read;
+ size_t new_ring_write;
+
+ printk( KERN_INFO "[glamo-drm] glamo add to ring %d bytes, ring_read: %d\n", count, glamo_get_read(gdrm));
+
+ up(&gdrm->add_to_ring);
+
+ ring_write = glamo_get_write(gdrm);
+
+ /* Calculate where we'll end up */
+ new_ring_write = (ring_write + count) % GLAMO_CMDQ_SIZE;
+
+ /* Wait until there is enough space to queue the cmd buffer */
+ if (new_ring_write > ring_write) {
+ /* Loop while the read pointer is between the old and new
+ * positions */
+ do {
+ ring_read = glamo_get_read(gdrm);
+ } while (ring_read > ring_write && ring_read < new_ring_write);
+ } else {
+ /* Same, but kind of inside-out */
+ do {
+ ring_read = glamo_get_read(gdrm);
+ } while (ring_read > ring_write || ring_read < new_ring_write);
+ }
+
+ /* Are we about to wrap around? */
+ if (ring_write >= new_ring_write) {
+
+ u32 rest_size;
+ printk(KERN_INFO "[glamo-drm] CmdQ wrap-around...\n");
+ /* Wrap around */
+ rest_size = GLAMO_CMDQ_SIZE - ring_write; /* Space left */
+
+ /* Write from current position to end */
+ memcpy_toio(gdrm->cmdq_base+ring_write, addr, rest_size);
+
+ /* Write from start */
+ memcpy_toio(gdrm->cmdq_base, addr+(rest_size>>1), count - rest_size);
+
+ /* ring_write being 0 will result in a deadlock because the
+ * cmdq read will never stop. To avoid such an behaviour insert
+ * an empty instruction. */
+ if (new_ring_write == 0) {
+ iowrite16(0x0000, gdrm->cmdq_base);
+ iowrite16(0x0000, gdrm->cmdq_base + 2);
+ new_ring_write = 4;
+ }
+
+ /* Suppose we just filled the WHOLE ring buffer, and so the
+ * write position ends up in the same place as it started.
+ * No change in poginter means no activity from the command
+ * queue engine. So, insert a no-op */
+ if (ring_write == new_ring_write) {
+ iowrite16(0x0000, gdrm->cmdq_base + new_ring_write);
+ iowrite16(0x0000, gdrm->cmdq_base + new_ring_write + 2);
+ new_ring_write += 4;
+ }
+
+ } else {
+
+ memcpy_toio(gdrm->cmdq_base+ring_write, addr,count);
+
+ }
+
+ reg_write(gdrm, GLAMO_REG_CMDQ_WRITE_ADDRH,
+ (new_ring_write >> 16) & 0x7f);
+ reg_write(gdrm, GLAMO_REG_CMDQ_WRITE_ADDRL,
+ new_ring_write & 0xffff);
+
+ down(&gdrm->add_to_ring);
+
+ printk( KERN_INFO "[glamo-drm] IOCTL2 CMDQ at: %d-%d, CMDQ CTRL: %d, CMDQ STATUS: %d\n",
+ glamo_get_read(gdrm), glamo_get_write(gdrm),
+ reg_read(gdrm, GLAMO_REG_CMDQ_CONTROL),
+ reg_read(gdrm, GLAMO_REG_CMDQ_STATUS) );
+
+
+ return 0;
+}
+
+/* Return true for a legal sequence of commands, otherwise false */
+static int glamo_sanitize_buffer(u16 *cmds, unsigned int count)
+{
+ /* XXX FIXME TODO: Implementation... */
+ return 1;
+}
+
+
+/* Substitute the real addresses in VRAM for any required buffer objects */
+static int glamo_do_relocation(struct glamodrm_handle *gdrm,
+ drm_glamo_cmd_buffer_t *cbuf, u16 *cmds,
+ struct drm_device *dev,
+ struct drm_file *file_priv)
+{
+ u32 *handles;
+ int *offsets;
+ int nobjs = cbuf->nobjs;
+ int i;
+
+ if ( nobjs > 32 ) return -EINVAL; /* Get real... */
+
+ handles = drm_alloc(nobjs*sizeof(u32), DRM_MEM_DRIVER);
+ if ( handles == NULL ) return -1;
+ if ( copy_from_user(handles, cbuf->objs, nobjs*sizeof(u32)) )
+ return -1;
+
+ offsets = drm_alloc(nobjs*sizeof(int), DRM_MEM_DRIVER);
+ if ( offsets == NULL ) return -1;
+ if ( copy_from_user(offsets, cbuf->obj_pos, nobjs*sizeof(int)) )
+ return -1;
+
+ for ( i=0; i<nobjs; i++ ) {
+
+ u32 handle = handles[i];
+ int offset = offsets[i];
+ struct drm_gem_object *obj;
+ struct drm_glamo_gem_object *gobj;
+ u32 addr;
+ u16 addr_low, addr_high;
+
+ printk(KERN_INFO "[glamo-drm] Relocating object handle %i "
+ "at position 0x%x\n", handle, offset);
+
+ if ( offset > cbuf->bufsz ) {
+ printk(KERN_WARNING "[glamo-drm] Offset out of range "
+ "for this relocation!\n");
+ goto fail;
+ }
+
+ obj = drm_gem_object_lookup(dev, file_priv, handle);
+ if ( obj == NULL ) return -1;
+
+ /* Unref the object now, or it'll never get freed.
+ * This should really happen after the GPU has finished
+ * the commands which are about to be submitted. */
+ drm_gem_object_unreference(obj);
+
+ gobj = obj->driver_private;
+ if ( gobj == NULL ) {
+ printk(KERN_WARNING "[glamo-drm] This object has no "
+ "private data!\n");
+ goto fail;
+ }
+
+ addr = GLAMO_OFFSET_WORK + gobj->block->start;
+ addr_low = addr & 0xffff;
+ addr_high = (addr >> 16) & 0x7f;
+ printk(KERN_INFO "Addr low 0x%x, high 0x%x\n",
+ addr_low, addr_high);
+
+ /* FIXME: Should really check that the register is a
+ * valid one for this relocation. */
+
+ *(cmds+(offset/2)+1) = addr_low;
+ *(cmds+(offset/2)+3) = addr_high;
+
+ }
+
+ drm_free(handles, 1, DRM_MEM_DRIVER);
+ drm_free(offsets, 1, DRM_MEM_DRIVER);
+ return 0;
+
+fail:
+ drm_free(handles, 1, DRM_MEM_DRIVER);
+ drm_free(offsets, 1, DRM_MEM_DRIVER);
+ return -1;
+}
+
+
+/* This is DRM_IOCTL_GLAMO_CMDBUF */
+int glamo_ioctl_cmdbuf(struct drm_device *dev, void *data,
+ struct drm_file *file_priv)
+{
+ int ret = 0;
+ struct glamodrm_handle *gdrm;
+ unsigned int count;
+ drm_glamo_cmd_buffer_t *cbuf = data;
+ u16 *cmds;
+
+ gdrm = dev->dev_private;
+
+ printk( KERN_INFO "[glamo-drm] IOCTL CMDQ at: %d-%d, CMDQ CTRL: %d, CMDQ STATUS: %d\n",
+ glamo_get_read(gdrm), glamo_get_write(gdrm),
+ reg_read(gdrm, GLAMO_REG_CMDQ_CONTROL),
+ reg_read(gdrm, GLAMO_REG_CMDQ_STATUS) );
+
+
+ count = cbuf->bufsz;
+
+ if ( count > PAGE_SIZE ) return -EINVAL;
+
+ cmds = drm_alloc(count, DRM_MEM_DRIVER);
+ if ( cmds == NULL ) return -ENOMEM;
+ if ( copy_from_user(cmds, cbuf->buf, count) ) {
+ printk( KERN_WARNING "[glamo-drm] copy from user failed\n");
+ ret = -EINVAL;
+ goto cleanup;
+ }
+
+ /* Check the buffer isn't going to tell Glamo to enact naughtiness */
+ if ( !glamo_sanitize_buffer(cmds, count) ) {
+ printk( KERN_WARNING "[glamo-drm] sanitize buffer failed\n");
+ ret = -EINVAL;
+ goto cleanup;
+ }
+
+ /* Perform relocation, if necessary */
+ if ( cbuf->nobjs ) {
+ if ( glamo_do_relocation(gdrm, cbuf, cmds, dev, file_priv) )
+ {
+ printk( KERN_WARNING "[glamo-drm] Relocation failed\n");
+ ret = -EINVAL;
+ goto cleanup;
+ }
+ }
+
+ glamo_add_to_ring(gdrm, cmds, count);
+
+
+cleanup:
+ drm_free(cmds, 1, DRM_MEM_DRIVER);
+
+ return ret;
+}
+
+
+int glamo_cmdq_init(struct glamodrm_handle *gdrm)
+{
+ unsigned int i;
+
+ init_MUTEX(&gdrm->add_to_ring);
+
+ /* Enable 2D and 3D */
+ glamo_engine_enable(gdrm->glamo_core, GLAMO_ENGINE_2D);
+ glamo_engine_reset(gdrm->glamo_core, GLAMO_ENGINE_2D);
+
+ /* Start by zeroing the command queue memory */
+ for ( i=0; i<GLAMO_CMDQ_SIZE; i+=2 ) {
+ iowrite16(0x0000, gdrm->cmdq_base+i);
+ }
+
+ glamo_engine_enable(gdrm->glamo_core, GLAMO_ENGINE_CMDQ);
+ glamo_engine_reset(gdrm->glamo_core, GLAMO_ENGINE_CMDQ);
+
+ /* Set up command queue location */
+ reg_write(gdrm, GLAMO_REG_CMDQ_BASE_ADDRL,
+ GLAMO_OFFSET_CMDQ & 0xffff);
+ reg_write(gdrm, GLAMO_REG_CMDQ_BASE_ADDRH,
+ (GLAMO_OFFSET_CMDQ >> 16) & 0x7f);
+
+ /* Length of command queue in 1k blocks, minus one */
+ reg_write(gdrm, GLAMO_REG_CMDQ_LEN, (GLAMO_CMDQ_SIZE >> 10)-1);
+ reg_write(gdrm, GLAMO_REG_CMDQ_WRITE_ADDRH, 0);
+ reg_write(gdrm, GLAMO_REG_CMDQ_WRITE_ADDRL, 0);
+ reg_write(gdrm, GLAMO_REG_CMDQ_CONTROL,
+ 1 << 12 | /* Turbo flip (?) */
+ 5 << 8 | /* no interrupt */
+ 8 << 4); /* HQ threshold */
+
+ printk( KERN_INFO "[glamo-drm] INIT CMDQ at: %d-%d, CMDQ CTRL: %d, CMDQ STATUS: %d\n",
+ glamo_get_read(gdrm), glamo_get_write(gdrm),
+ reg_read(gdrm, GLAMO_REG_CMDQ_CONTROL),
+ reg_read(gdrm, GLAMO_REG_CMDQ_STATUS) );
+
+ return 0;
+}
+
+int glamo_cmdq_shutdown(struct glamodrm_handle *gdrm)
+{
+ return 0;
+}
diff --git a/drivers/mfd/glamo/glamo-cmdq.h b/drivers/mfd/glamo/glamo-cmdq.h
new file mode 100644
index 00000000000..e72fea9bec5
--- /dev/null
+++ b/drivers/mfd/glamo/glamo-cmdq.h
@@ -0,0 +1,41 @@
+/* Smedia Glamo 336x/337x command queue handling
+ *
+ * Copyright (c) 2008-2009 Thomas White <taw@bitwiz.org.uk>
+ * Copyright (c) 2009 Andreas Pokorny <andreas.pokorny@gmail.com>
+ * Based on xf86-video-glamo
+ * Copyright 2007 OpenMoko, Inc.
+ * Copyright © 2009 Lars-Peter Clausen <lars@metafoo.de>
+ *
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#ifndef __GLAMO_CMDQ_H
+#define __GLAMO_CMDQ_H
+
+#include <drm/drmP.h>
+
+#include "glamo-drm-private.h"
+
+extern int glamo_ioctl_cmdbuf(struct drm_device *dev, void *data,
+ struct drm_file *file_priv);
+
+extern int glamo_cmdq_init(struct glamodrm_handle *gdrm);
+extern int glamo_cmdq_shutdown(struct glamodrm_handle *gdrm);
+
+
+#endif /* __GLAMO_CMDQ_H */
diff --git a/drivers/mfd/glamo/glamo-core.c b/drivers/mfd/glamo/glamo-core.c
index 28dc1f309ac..a485e34f748 100644
--- a/drivers/mfd/glamo/glamo-core.c
+++ b/drivers/mfd/glamo/glamo-core.c
@@ -175,93 +175,31 @@ static inline void glamo_vmem_read(struct glamo_core *glamo, u_int16_t *buf,
/***********************************************************************
* resources of sibling devices
***********************************************************************/
-
-#if 0
-static struct resource glamo_core_resources[] = {
- {
- .start = GLAMO_REGOFS_GENERIC,
- .end = GLAMO_REGOFS_GENERIC + 0x400,
- .flags = IORESOURCE_MEM,
- }, {
- .start = 0,
- .end = 0,
- .flags = IORESOURCE_IRQ,
- },
-};
-
-static struct platform_device glamo_core_dev = {
- .name = "glamo-core",
- .resource = &glamo_core_resources,
- .num_resources = ARRAY_SIZE(glamo_core_resources),
-};
-#endif
-
-static struct resource glamo_jpeg_resources[] = {
+static struct resource glamo_cmdq_resources[] = {
{
- .start = GLAMO_REGOFS_JPEG,
- .end = GLAMO_REGOFS_MPEG - 1,
- .flags = IORESOURCE_MEM,
- }, {
- .start = IRQ_GLAMO_JPEG,
- .end = IRQ_GLAMO_JPEG,
- .flags = IORESOURCE_IRQ,
- },
-};
-
-static struct platform_device glamo_jpeg_dev = {
- .name = "glamo-jpeg",
- .resource = glamo_jpeg_resources,
- .num_resources = ARRAY_SIZE(glamo_jpeg_resources),
-};
-
-static struct resource glamo_mpeg_resources[] = {
- {
- .start = GLAMO_REGOFS_MPEG,
- .end = GLAMO_REGOFS_LCD - 1,
- .flags = IORESOURCE_MEM,
+ .name = "glamo-cmdq-regs",
+ .start = GLAMO_REGOFS_CMDQUEUE,
+ .end = GLAMO_REGOFS_RISC - 1,
+ .flags = IORESOURCE_MEM,
}, {
- .start = IRQ_GLAMO_MPEG,
- .end = IRQ_GLAMO_MPEG,
- .flags = IORESOURCE_IRQ,
- },
-};
-
-static struct platform_device glamo_mpeg_dev = {
- .name = "glamo-mpeg",
- .resource = glamo_mpeg_resources,
- .num_resources = ARRAY_SIZE(glamo_mpeg_resources),
-};
-
-static struct resource glamo_2d_resources[] = {
- {
- .start = GLAMO_REGOFS_2D,
- .end = GLAMO_REGOFS_3D - 1,
- .flags = IORESOURCE_MEM,
+ .name = "glamo-work-mem",
+ .start = GLAMO_MEM_BASE + GLAMO_OFFSET_WORK,
+ .end = GLAMO_MEM_BASE + GLAMO_OFFSET_WORK +
+ GLAMO_WORK_SIZE - 1,
+ .flags = IORESOURCE_MEM,
}, {
- .start = IRQ_GLAMO_2D,
- .end = IRQ_GLAMO_2D,
- .flags = IORESOURCE_IRQ,
- },
-};
-
-static struct platform_device glamo_2d_dev = {
- .name = "glamo-2d",
- .resource = glamo_2d_resources,
- .num_resources = ARRAY_SIZE(glamo_2d_resources),
-};
-
-static struct resource glamo_3d_resources[] = {
- {
- .start = GLAMO_REGOFS_3D,
- .end = GLAMO_REGOFS_END - 1,
- .flags = IORESOURCE_MEM,
+ .name = "glamo-command-queue",
+ .start = GLAMO_MEM_BASE + GLAMO_OFFSET_CMDQ,
+ .end = GLAMO_MEM_BASE + GLAMO_OFFSET_CMDQ +
+ GLAMO_CMDQ_SIZE - 1,
+ .flags = IORESOURCE_MEM,
},
};
-static struct platform_device glamo_3d_dev = {
- .name = "glamo-3d",
- .resource = glamo_3d_resources,
- .num_resources = ARRAY_SIZE(glamo_3d_resources),
+static struct platform_device glamo_cmdq_dev = {
+ .name = "glamo-cmdq",
+ .resource = glamo_cmdq_resources,
+ .num_resources = ARRAY_SIZE(glamo_cmdq_resources),
};
static struct platform_device glamo_spigpio_dev = {
@@ -277,8 +215,9 @@ static struct resource glamo_fb_resources[] = {
.flags = IORESOURCE_MEM,
}, {
.name = "glamo-fb-mem",
- .start = GLAMO_OFFSET_FB,
- .end = GLAMO_OFFSET_FB + GLAMO_FB_SIZE - 1,
+ .start = GLAMO_MEM_BASE + GLAMO_OFFSET_FB,
+ .end = GLAMO_MEM_BASE + GLAMO_OFFSET_FB +
+ GLAMO_FB_SIZE - 1,
.flags = IORESOURCE_MEM,
},
};
@@ -300,9 +239,9 @@ static struct resource glamo_mmc_resources[] = {
.end = IRQ_GLAMO_MMC,
.flags = IORESOURCE_IRQ,
}, { /* our data buffer for MMC transfers */
- .start = GLAMO_OFFSET_FB + GLAMO_FB_SIZE,
- .end = GLAMO_OFFSET_FB + GLAMO_FB_SIZE +
- GLAMO_MMC_BUFFER_SIZE - 1,
+ .start = GLAMO_MEM_BASE + GLAMO_OFFSET_MMC,
+ .end = GLAMO_MEM_BASE + GLAMO_OFFSET_MMC +
+ GLAMO_MMC_BUFFER_SIZE - 1,
.flags = IORESOURCE_MEM
},
};
@@ -538,6 +477,8 @@ int __glamo_engine_enable(struct glamo_core *glamo, enum glamo_engine engine)
__reg_set_bit_mask(glamo, GLAMO_REG_HOSTBUS(2),
GLAMO_HOSTBUS2_MMIO_EN_2D,
GLAMO_HOSTBUS2_MMIO_EN_2D);
+ __reg_set_bit_mask(glamo, GLAMO_REG_CLOCK_GEN5_1,
+ GLAMO_CLOCK_GEN51_EN_DIV_GCLK, 0xffff);
break;
case GLAMO_ENGINE_CMDQ:
__reg_set_bit_mask(glamo, GLAMO_REG_CLOCK_2D,
@@ -545,6 +486,8 @@ int __glamo_engine_enable(struct glamo_core *glamo, enum glamo_engine engine)
__reg_set_bit_mask(glamo, GLAMO_REG_HOSTBUS(2),
GLAMO_HOSTBUS2_MMIO_EN_CQ,
GLAMO_HOSTBUS2_MMIO_EN_CQ);
+ __reg_set_bit_mask(glamo, GLAMO_REG_CLOCK_GEN5_1,
+ GLAMO_CLOCK_GEN51_EN_DIV_MCLK, 0xffff);
break;
/* FIXME: Implementation */
default:
@@ -675,6 +618,11 @@ struct glamo_script reset_regs[] = {
[GLAMO_ENGINE_JPEG] = {
GLAMO_REG_CLOCK_JPEG, GLAMO_CLOCK_JPEG_RESET
},
+ /* The following is defined as "Reset command queue", nothing to do
+ * with the 2D engine. */
+ [GLAMO_ENGINE_CMDQ] = {
+ GLAMO_REG_CLOCK_2D, GLAMO_CLOCK_2D_CQ_RESET
+ },
};
void glamo_engine_reset(struct glamo_core *glamo, enum glamo_engine engine)
@@ -983,7 +931,7 @@ static void glamo_power(struct glamo_core *glamo,
{
int n;
unsigned long flags;
-
+
spin_lock_irqsave(&glamo->lock, flags);
dev_info(&glamo->pdev->dev, "***** glamo_power -> %d\n", new_state);
@@ -1308,52 +1256,40 @@ static int __init glamo_probe(struct platform_device *pdev)
glamo->pdata->glamo_irq_is_wired;
/* start creating the siblings */
+ glamo->pdata->glamo = glamo;
- glamo_2d_dev.dev.parent = &pdev->dev;
- mangle_mem_resources(glamo_2d_dev.resource,
- glamo_2d_dev.num_resources, glamo->mem);
- platform_device_register(&glamo_2d_dev);
-
- glamo_3d_dev.dev.parent = &pdev->dev;
- mangle_mem_resources(glamo_3d_dev.resource,
- glamo_3d_dev.num_resources, glamo->mem);
- platform_device_register(&glamo_3d_dev);
-
- glamo_jpeg_dev.dev.parent = &pdev->dev;
- mangle_mem_resources(glamo_jpeg_dev.resource,
- glamo_jpeg_dev.num_resources, glamo->mem);
- platform_device_register(&glamo_jpeg_dev);
-
- glamo_mpeg_dev.dev.parent = &pdev->dev;
- mangle_mem_resources(glamo_mpeg_dev.resource,
- glamo_mpeg_dev.num_resources, glamo->mem);
- platform_device_register(&glamo_mpeg_dev);
+ /* Command queue device (for DRM) */
+ glamo_cmdq_dev.dev.parent = &pdev->dev;
+ glamo_cmdq_dev.dev.platform_data = glamo;
+ mangle_mem_resources(glamo_cmdq_dev.resource,
+ glamo_cmdq_dev.num_resources, glamo->mem);
+ platform_device_register(&glamo_cmdq_dev);
- glamo->pdata->glamo = glamo;
+ /* Frambuffer device */
glamo_fb_dev.dev.parent = &pdev->dev;
glamo_fb_dev.dev.platform_data = glamo->pdata;
mangle_mem_resources(glamo_fb_dev.resource,
glamo_fb_dev.num_resources, glamo->mem);
platform_device_register(&glamo_fb_dev);
+ /* GPIO */
glamo->pdata->spigpio_info->glamo = glamo;
glamo_spigpio_dev.dev.parent = &pdev->dev;
glamo_spigpio_dev.dev.platform_data = glamo->pdata->spigpio_info;
platform_device_register(&glamo_spigpio_dev);
+ /* MMC */
glamo_mmc_dev = glamo->pdata->mmc_dev;
glamo_mmc_dev->name = "glamo-mci";
glamo_mmc_dev->dev.parent = &pdev->dev;
glamo_mmc_dev->resource = glamo_mmc_resources;
- glamo_mmc_dev->num_resources = ARRAY_SIZE(glamo_mmc_resources);
-
- /* we need it later to give to the engine enable and disable */
+ glamo_mmc_dev->num_resources = ARRAY_SIZE(glamo_mmc_resources);
glamo_mci_def_pdata.pglamo = glamo;
mangle_mem_resources(glamo_mmc_dev->resource,
glamo_mmc_dev->num_resources, glamo->mem);
platform_device_register(glamo_mmc_dev);
- /* only request the generic, hostbus and memory controller MMIO */
+ /* Only request the generic, hostbus and memory controller MMIO */
glamo->mem = request_mem_region(glamo->mem->start,
GLAMO_REGOFS_VIDCAP, "glamo-core");
if (!glamo->mem) {
diff --git a/drivers/mfd/glamo/glamo-core.h b/drivers/mfd/glamo/glamo-core.h
index 8e09564bc3f..63390492141 100644
--- a/drivers/mfd/glamo/glamo-core.h
+++ b/drivers/mfd/glamo/glamo-core.h
@@ -3,18 +3,35 @@
#include <asm/system.h>
-/* for the time being, we put the on-screen framebuffer into the lowest
- * VRAM space. This should make the code easily compatible with the various
- * 2MB/4MB/8MB variants of the Smedia chips */
-#define GLAMO_OFFSET_VRAM 0x800000
-#define GLAMO_OFFSET_FB (GLAMO_OFFSET_VRAM)
-
/* we only allocate the minimum possible size for the framebuffer to make
* sure we have sufficient memory for other functions of the chip */
-//#define GLAMO_FB_SIZE (640*480*4) /* == 0x12c000 */
+/* FIXME: this should be autodetected */
#define GLAMO_INTERNAL_RAM_SIZE 0x800000
-#define GLAMO_MMC_BUFFER_SIZE (64 * 1024)
-#define GLAMO_FB_SIZE (GLAMO_INTERNAL_RAM_SIZE - GLAMO_MMC_BUFFER_SIZE)
+/* A 640x480, 16bpp, double-buffered framebuffer */
+#define GLAMO_FB_SIZE (640 * 480 * 4) /* == 0x12c000 */
+/* Arbitrarily determined amount for the hardware cursor */
+#define GLAMO_CURSOR_SIZE (4096)
+#define GLAMO_MMC_BUFFER_SIZE (64 * 1024) /* 64k MMC buffer */
+#define GLAMO_CMDQ_SIZE (128 * 1024) /* 128k ring buffer */
+/* Remaining memory will be used for 2D and 3D graphics */
+#define GLAMO_WORK_SIZE (GLAMO_INTERNAL_RAM_SIZE \
+ - GLAMO_FB_SIZE \
+ - GLAMO_CURSOR_SIZE \
+ - GLAMO_MMC_BUFFER_SIZE \
+ - GLAMO_CMDQ_SIZE)
+
+/* for the time being, we put the on-screen framebuffer into the lowest
+ * VRAM space. This should make the code easily compatible with the various
+ * 2MB/4MB/8MB variants of the Smedia chips
+ * glamo-fb.c assumes FB comes first, followed by cursor, so DON'T MOVE THEM
+ * (see glamo_regs[] in glamo-fb.c for more information) */
+#define GLAMO_MEM_BASE (0x800000)
+#define GLAMO_OFFSET_VRAM (0x000000)
+#define GLAMO_OFFSET_FB (GLAMO_OFFSET_VRAM)
+#define GLAMO_OFFSET_CURSOR (GLAMO_OFFSET_FB + GLAMO_FB_SIZE)
+#define GLAMO_OFFSET_MMC (GLAMO_OFFSET_CURSOR + GLAMO_CURSOR_SIZE)
+#define GLAMO_OFFSET_CMDQ (GLAMO_OFFSET_MMC + GLAMO_MMC_BUFFER_SIZE)
+#define GLAMO_OFFSET_WORK (GLAMO_OFFSET_CMDQ + GLAMO_CMDQ_SIZE)
struct glamo_core {
int irq;
@@ -60,7 +77,8 @@ enum glamo_engine {
GLAMO_ENGINE_RISC1,
GLAMO_ENGINE_SPI,
#endif
- __NUM_GLAMO_ENGINES
+ __NUM_GLAMO_ENGINES,
+ GLAMO_ENGINE_ALL
};
struct glamo_mci_pdata {
diff --git a/drivers/mfd/glamo/glamo-drm-drv.c b/drivers/mfd/glamo/glamo-drm-drv.c
new file mode 100644
index 00000000000..856622d9e76
--- /dev/null
+++ b/drivers/mfd/glamo/glamo-drm-drv.c
@@ -0,0 +1,350 @@
+/* Smedia Glamo 336x/337x driver
+ *
+ * Copyright (C) 2009 Openmoko, Inc. Jorge Luis Zapata <turran@openmoko.com>
+ * Copyright (C) 2008-2009 Thomas White <taw@bitwiz.org.uk>
+ * Copyright (C) 2009 Andreas Pokorny <andreas.pokorny@gmail.com>
+ *
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <drm/drmP.h>
+#include <drm/glamo_drm.h>
+
+#include "glamo-core.h"
+#include "glamo-cmdq.h"
+#include "glamo-buffer.h"
+#include "glamo-drm-private.h"
+
+#define DRIVER_AUTHOR "Openmoko, Inc."
+#define DRIVER_NAME "glamo-drm"
+#define DRIVER_DESC "SMedia Glamo 3362"
+#define DRIVER_DATE "20090426"
+
+#define RESSIZE(ressource) (((ressource)->end - (ressource)->start)+1)
+
+
+static int glamo_ioctl_swap(struct drm_device *dev, void *data,
+ struct drm_file *file_priv)
+{
+ printk(KERN_INFO "glamo_ioctl_swap\n");
+ return 0;
+}
+
+
+static int glamo_ioctl_gem_info(struct drm_device *dev, void *data,
+ struct drm_file *file_priv)
+{
+ printk(KERN_INFO "glamo_ioctl_gem_info\n");
+ return 0;
+}
+
+
+static int glamo_ioctl_gem_wait_rendering(struct drm_device *dev, void *data,
+ struct drm_file *file_priv)
+{
+ printk(KERN_INFO "glamo_ioctl_gem_wait_rendering\n");
+ return 0;
+}
+
+
+struct drm_ioctl_desc glamo_ioctls[] = {
+ DRM_IOCTL_DEF(DRM_GLAMO_CMDBUF, glamo_ioctl_cmdbuf, DRM_AUTH),
+ DRM_IOCTL_DEF(DRM_GLAMO_SWAP, glamo_ioctl_swap, DRM_AUTH),
+ DRM_IOCTL_DEF(DRM_GLAMO_GEM_INFO, glamo_ioctl_gem_info, DRM_AUTH),
+ DRM_IOCTL_DEF(DRM_GLAMO_GEM_CREATE, glamo_ioctl_gem_create, DRM_AUTH),
+ DRM_IOCTL_DEF(DRM_GLAMO_GEM_MMAP, glamo_ioctl_gem_mmap, DRM_AUTH),
+ DRM_IOCTL_DEF(DRM_GLAMO_GEM_PIN, glamo_ioctl_gem_pin, DRM_AUTH),
+ DRM_IOCTL_DEF(DRM_GLAMO_GEM_UNPIN, glamo_ioctl_gem_unpin, DRM_AUTH),
+ DRM_IOCTL_DEF(DRM_GLAMO_GEM_PREAD, glamo_ioctl_gem_pread, DRM_AUTH),
+ DRM_IOCTL_DEF(DRM_GLAMO_GEM_PWRITE, glamo_ioctl_gem_pwrite, DRM_AUTH),
+ DRM_IOCTL_DEF(DRM_GLAMO_GEM_WAIT_RENDERING,
+ glamo_ioctl_gem_wait_rendering, DRM_AUTH),
+};
+
+
+static int glamodrm_firstopen(struct drm_device *dev)
+{
+ DRM_DEBUG("\n");
+ return 0;
+}
+
+
+static int glamodrm_open(struct drm_device *dev, struct drm_file *fh)
+{
+ DRM_DEBUG("\n");
+ return 0;
+}
+
+
+static void glamodrm_preclose(struct drm_device *dev, struct drm_file *fh)
+{
+ DRM_DEBUG("\n");
+}
+
+static void glamodrm_postclose(struct drm_device *dev, struct drm_file *fh)
+{
+ DRM_DEBUG("\n");
+}
+
+
+static void glamodrm_lastclose(struct drm_device *dev)
+{
+ DRM_DEBUG("\n");
+}
+
+
+static int glamodrm_master_create(struct drm_device *dev,
+ struct drm_master *master)
+{
+ DRM_DEBUG("\n");
+
+ return 0;
+}
+
+
+static void glamodrm_master_destroy(struct drm_device *dev,
+ struct drm_master *master)
+{
+ DRM_DEBUG("\n");
+}
+
+
+static struct vm_operations_struct glamodrm_gem_vm_ops = {
+ .fault = glamodrm_gem_fault,
+};
+
+static struct drm_driver glamodrm_drm_driver = {
+ .driver_features = DRIVER_IS_PLATFORM | DRIVER_GEM,
+ .firstopen = glamodrm_firstopen,
+ .open = glamodrm_open,
+ .preclose = glamodrm_preclose,
+ .postclose = glamodrm_postclose,
+ .lastclose = glamodrm_lastclose,
+ .reclaim_buffers = drm_core_reclaim_buffers,
+ .get_map_ofs = drm_core_get_map_ofs,
+ .get_reg_ofs = drm_core_get_reg_ofs,
+ .master_create = glamodrm_master_create,
+ .master_destroy = glamodrm_master_destroy,
+ .gem_init_object = glamodrm_gem_init_object,
+ .gem_free_object = glamodrm_gem_free_object,
+ .gem_vm_ops = &glamodrm_gem_vm_ops,
+ .ioctls = glamo_ioctls,
+ .fops = {
+ .owner = THIS_MODULE,
+ .open = drm_open,
+ .release = drm_release,
+ .ioctl = drm_ioctl,
+ .mmap = drm_mmap,
+ .poll = drm_poll,
+ .fasync = drm_fasync,
+ },
+ .major = 0,
+ .minor = 1,
+ .patchlevel = 0,
+ .name = DRIVER_NAME,
+ .desc = DRIVER_DESC,
+ .date = DRIVER_DATE,
+};
+
+
+static int glamodrm_probe(struct platform_device *pdev)
+{
+ int rc;
+ struct glamodrm_handle *gdrm;
+
+ printk(KERN_INFO "[glamo-drm] SMedia Glamo Direct Rendering Support\n");
+
+ gdrm = kmalloc(sizeof(*gdrm), GFP_KERNEL);
+ if ( !gdrm )
+ return -ENOMEM;
+ platform_set_drvdata(pdev, gdrm);
+ gdrm->glamo_core = pdev->dev.platform_data;
+
+ /* Find the command queue registers */
+ gdrm->reg = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ if ( !gdrm->reg ) {
+ dev_err(&pdev->dev, "Unable to find cmdq registers.\n");
+ rc = -ENOENT;
+ goto out_free;
+ }
+ gdrm->reg = request_mem_region(gdrm->reg->start,
+ RESSIZE(gdrm->reg), pdev->name);
+ if ( !gdrm->reg ) {
+ dev_err(&pdev->dev, "failed to request MMIO region\n");
+ rc = -ENOENT;
+ goto out_free;
+ }
+ gdrm->reg_base = ioremap(gdrm->reg->start, RESSIZE(gdrm->reg));
+ if ( !gdrm->reg_base ) {
+ dev_err(&pdev->dev, "failed to ioremap() MMIO registers\n");
+ rc = -ENOENT;
+ goto out_release_regs;
+ }
+
+ /* Find the working VRAM */
+ gdrm->vram = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+ if ( !gdrm->vram ) {
+ dev_err(&pdev->dev, "Unable to find work VRAM.\n");
+ rc = -ENOENT;
+ goto out_unmap_regs;
+ }
+ gdrm->vram = request_mem_region(gdrm->vram->start,
+ RESSIZE(gdrm->vram), pdev->name);
+ if ( !gdrm->vram ) {
+ dev_err(&pdev->dev, "failed to request VRAM region\n");
+ rc = -ENOENT;
+ goto out_unmap_regs;
+ }
+ gdrm->vram_base = ioremap(gdrm->vram->start, RESSIZE(gdrm->vram));
+ if ( !gdrm->vram_base ) {
+ dev_err(&pdev->dev, "failed to ioremap() VRAM\n");
+ rc = -ENOENT;
+ goto out_release_vram;
+ }
+
+ gdrm->vram_size = GLAMO_WORK_SIZE;
+ printk(KERN_INFO "[glamo-drm] %lli bytes of Glamo RAM to work with\n",
+ (long long int)gdrm->vram_size);
+
+ /* Find the command queue itself */
+ gdrm->cmdq = platform_get_resource(pdev, IORESOURCE_MEM, 2);
+ if ( !gdrm->cmdq ) {
+ dev_err(&pdev->dev, "Unable to find command queue.\n");
+ rc = -ENOENT;
+ goto out_unmap_vram;
+ }
+ gdrm->cmdq = request_mem_region(gdrm->cmdq->start,
+ RESSIZE(gdrm->cmdq), pdev->name);
+ if ( !gdrm->cmdq ) {
+ dev_err(&pdev->dev, "failed to request command queue region\n");
+ rc = -ENOENT;
+ goto out_unmap_vram;
+ }
+ gdrm->cmdq_base = ioremap(gdrm->cmdq->start, RESSIZE(gdrm->cmdq));
+ if ( !gdrm->cmdq_base ) {
+ dev_err(&pdev->dev, "failed to ioremap() command queue\n");
+ rc = -ENOENT;
+ goto out_release_cmdq;
+ }
+
+ /* Initialise DRM */
+ drm_platform_init(&glamodrm_drm_driver, pdev, (void *)gdrm);
+
+ glamo_buffer_init(gdrm);
+ glamo_cmdq_init(gdrm);
+
+ return 0;
+
+out_release_cmdq:
+ release_mem_region(gdrm->cmdq->start, RESSIZE(gdrm->cmdq));
+out_unmap_vram:
+ iounmap(gdrm->vram_base);
+out_release_vram:
+ release_mem_region(gdrm->vram->start, RESSIZE(gdrm->vram));
+out_unmap_regs:
+ iounmap(gdrm->reg_base);
+out_release_regs:
+ release_mem_region(gdrm->reg->start, RESSIZE(gdrm->reg));
+out_free:
+ kfree(gdrm);
+ pdev->dev.driver_data = NULL;
+ return rc;
+}
+
+
+static int glamodrm_remove(struct platform_device *pdev)
+{
+ struct glamodrm_handle *gdrm = platform_get_drvdata(pdev);
+ struct glamo_core *glamocore = pdev->dev.platform_data;
+
+ glamo_engine_disable(glamocore, GLAMO_ENGINE_2D);
+ glamo_engine_disable(glamocore, GLAMO_ENGINE_3D);
+
+ glamo_buffer_final(gdrm);
+ glamo_cmdq_shutdown(gdrm);
+ drm_exit(&glamodrm_drm_driver);
+
+ platform_set_drvdata(pdev, NULL);
+
+ /* Release registers */
+ iounmap(gdrm->reg_base);
+ release_mem_region(gdrm->reg->start, RESSIZE(gdrm->reg));
+
+ /* Release VRAM */
+ iounmap(gdrm->vram_base);
+ release_mem_region(gdrm->vram->start, RESSIZE(gdrm->vram));
+
+ /* Release command queue */
+ iounmap(gdrm->cmdq_base);
+ release_mem_region(gdrm->cmdq->start, RESSIZE(gdrm->cmdq));
+
+ kfree(gdrm);
+
+ return 0;
+}
+
+
+static int glamodrm_suspend(struct platform_device *pdev, pm_message_t state)
+{
+ /* glamo_core.c will suspend the engines for us */
+ return 0;
+}
+
+
+static int glamodrm_resume(struct platform_device *pdev)
+{
+ struct glamodrm_handle *gdrm = platform_get_drvdata(pdev);
+ glamo_cmdq_init(gdrm);
+ return 0;
+}
+
+
+static struct platform_driver glamodrm_driver = {
+ .probe = glamodrm_probe,
+ .remove = glamodrm_remove,
+ .suspend = glamodrm_suspend,
+ .resume = glamodrm_resume,
+ .driver = {
+ .name = "glamo-cmdq",
+ .owner = THIS_MODULE,
+ },
+};
+
+
+static int __devinit glamodrm_init(void)
+{
+ glamodrm_drm_driver.num_ioctls = DRM_ARRAY_SIZE(glamo_ioctls);
+ return platform_driver_register(&glamodrm_driver);
+}
+
+
+static void __exit glamodrm_exit(void)
+{
+ platform_driver_unregister(&glamodrm_driver);
+}
+
+
+module_init(glamodrm_init);
+module_exit(glamodrm_exit);
+
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
diff --git a/drivers/mfd/glamo/glamo-drm-private.h b/drivers/mfd/glamo/glamo-drm-private.h
new file mode 100644
index 00000000000..4cc5877e118
--- /dev/null
+++ b/drivers/mfd/glamo/glamo-drm-private.h
@@ -0,0 +1,74 @@
+/* Smedia Glamo 336x/337x DRM private bits
+ *
+ * Copyright (C) 2008-2009 Thomas White <taw@bitwiz.org.uk>
+ * Copyright (C) 2009 Andreas Pokorny <andreas.pokorny@gmail.com>
+ * Based on xf86-video-glamo
+ * Copyright 2007 OpenMoko, Inc.
+ * Copyright © 2009 Lars-Peter Clausen <lars@metafoo.de>
+ *
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#ifndef __GLAMO_DRMPRIV_H
+#define __GLAMO_DRMPRIV_H
+
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/semaphore.h>
+
+#include "glamo-core.h"
+
+
+struct glamodrm_handle {
+
+ /* This device */
+ struct device *dev;
+ /* The parent device handle */
+ struct glamo_core *glamo_core;
+
+ /* Command queue registers */
+ struct resource *reg;
+ char __iomem *reg_base;
+
+ /* VRAM region */
+ struct resource *vram;
+ char __iomem *vram_base;
+
+ /* Command queue region */
+ struct resource *cmdq;
+ char __iomem *cmdq_base;
+
+ ssize_t vram_size;
+
+ /* Memory management */
+ struct drm_mm *mmgr;
+
+ /* semaphore against concurrent ioctl */
+ struct semaphore add_to_ring;
+};
+
+/* Private data. This is where we keep our memory management bits */
+struct drm_glamo_gem_object {
+ struct drm_gem_object *obj; /* The GEM object this refers to */
+ struct drm_mm_node *block; /* Block handle for drm_mm */
+};
+
+
+
+#endif /* __GLAMO_DRMPRIV_H */
diff --git a/drivers/mfd/glamo/glamo-fb.c b/drivers/mfd/glamo/glamo-fb.c
index 1ebb87d1276..589b924b6bf 100644
--- a/drivers/mfd/glamo/glamo-fb.c
+++ b/drivers/mfd/glamo/glamo-fb.c
@@ -734,6 +734,12 @@ static int glamofb_cursor(struct fb_info *info, struct fb_cursor *cursor)
struct glamofb_handle *glamo = info->par;
unsigned long flags;
+ /* Reject if the cursor is too big to fit in the memory allocated in
+ * glamo-core.h */
+
+ if ((cursor->image.width * cursor->image.height) > GLAMO_CURSOR_SIZE )
+ return -EINVAL;
+
spin_lock_irqsave(&glamo->lock_cmd, flags);
reg_write(glamo, GLAMO_REG_LCD_CURSOR_X_SIZE,
@@ -989,6 +995,8 @@ static int __init glamofb_probe(struct platform_device *pdev)
dev_err(&pdev->dev, "failed to request mmio region\n");
goto out_free;
}
+ if (mach_info->fb_mem_size != RESSIZE(glamofb->fb_res))
+ dev_warn(&pdev->dev, "different vram sizes\n");
glamofb->fb_res = request_mem_region(glamofb->fb_res->start,
mach_info->fb_mem_size,
diff --git a/drivers/mfd/glamo/glamo-mci.c b/drivers/mfd/glamo/glamo-mci.c
index bc3ed66d43c..b9442091d02 100644
--- a/drivers/mfd/glamo/glamo-mci.c
+++ b/drivers/mfd/glamo/glamo-mci.c
@@ -573,15 +573,15 @@ static int glamo_mci_prepare_pio(struct glamo_mci_host *host,
* Read is halfway up the buffer and write is at the start
*/
if (data->flags & MMC_DATA_READ) {
- writew((u16)(GLAMO_FB_SIZE + (RESSIZE(host->mem_data) / 2)),
+ writew((u16)(GLAMO_OFFSET_MMC + (RESSIZE(host->mem_data) / 2)),
host->base + GLAMO_REG_MMC_WDATADS1);
- writew((u16)((GLAMO_FB_SIZE +
+ writew((u16)((GLAMO_OFFSET_MMC +
(RESSIZE(host->mem_data) / 2)) >> 16),
host->base + GLAMO_REG_MMC_WDATADS2);
} else {
- writew((u16)GLAMO_FB_SIZE, host->base +
+ writew((u16)GLAMO_OFFSET_MMC, host->base +
GLAMO_REG_MMC_RDATADS1);
- writew((u16)(GLAMO_FB_SIZE >> 16), host->base +
+ writew((u16)(GLAMO_OFFSET_MMC >> 16), host->base +
GLAMO_REG_MMC_RDATADS2);
}
diff --git a/drivers/mfd/glamo/glamo-regs.h b/drivers/mfd/glamo/glamo-regs.h
index 2328b8ac989..738cb64369b 100644
--- a/drivers/mfd/glamo/glamo-regs.h
+++ b/drivers/mfd/glamo/glamo-regs.h
@@ -629,4 +629,17 @@ enum glamo_core_revisions {
GLAMO_CORE_REV_A3 = 0x0003,
};
+enum glamo_register_cq {
+ GLAMO_REG_CMDQ_BASE_ADDRL = 0x00,
+ GLAMO_REG_CMDQ_BASE_ADDRH = 0x02,
+ GLAMO_REG_CMDQ_LEN = 0x04,
+ GLAMO_REG_CMDQ_WRITE_ADDRL = 0x06,
+ GLAMO_REG_CMDQ_WRITE_ADDRH = 0x08,
+ GLAMO_REG_CMDQ_FLIP = 0x0a,
+ GLAMO_REG_CMDQ_CONTROL = 0x0c,
+ GLAMO_REG_CMDQ_READ_ADDRL = 0x0e,
+ GLAMO_REG_CMDQ_READ_ADDRH = 0x10,
+ GLAMO_REG_CMDQ_STATUS = 0x12,
+};
+
#endif /* _GLAMO_REGS_H */
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-13 15:24:07 +0000