TILER: Cleaned up tmm-pat.c

Removed unnecessary initializations.

Simplified page allocation logic by directly allocating pages
instead of going through free_page list.

Made page and memory allocation global, so that page cache can
be shared between PATs.

Now deinitialization logic works with multiple PATs.

Signed-off-by: Lajos Molnar <molnar@ti.com>
Signed-off-by: David Sin <davidsin@ti.com>

TILER: Simplified dmm.c

Removed unnecessary type casting.
Updated logic to common bitfield setting macro.
Removed unnecessary step-by-step register modifications.

Signed-off-by: Lajos Molnar <molnar@ti.com>
Signed-off-by: David Sin <davidsin@ti.com>

TILER: Cleaned up tcm API definitions.

Fixed comments.
Removed unused methods.
Removed AREA_FMT macro that caused a checkpatch failure.
Added further error checking to tcm methods.

Signed-off-by: Lajos Molnar <molnar@ti.com>
Signed-off-by: David Sin <davidsin@ti.com>

6 files changed, 220 insertions, 387 deletions

diff --git a/arch/arm/mach-omap2/include/mach/dmm.h b/arch/arm/mach-omap2/include/mach/dmm.h
index 700f08aefbc..77f824d2a8c 100644
--- a/arch/arm/mach-omap2/include/mach/dmm.h
+++ b/arch/arm/mach-omap2/include/mach/dmm.h
@@ -3,6 +3,8 @@
  *
  * DMM driver support functions for TI OMAP processors.
  *
+ * Author: David Sin <davidsin@ti.com>
+ *
  * Copyright (C) 2009-2010 Texas Instruments, Inc.
  *
  * This package is free software; you can redistribute it and/or modify
diff --git a/drivers/media/video/tiler/dmm.c b/drivers/media/video/tiler/dmm.c
index 8663b36a5e7..685a1935a7f 100644
--- a/drivers/media/video/tiler/dmm.c
+++ b/drivers/media/video/tiler/dmm.c
@@ -3,6 +3,9 @@
  *
  * DMM driver support functions for TI OMAP processors.
  *
+ * Authors: David Sin <davidsin@ti.com>
+ *          Lajos Molnar <molnar@ti.com>
+ *
  * Copyright (C) 2009-2010 Texas Instruments, Inc.
  *
  * This package is free software; you can redistribute it and/or modify
@@ -16,10 +19,6 @@
 
 #include <linux/init.h>
 #include <linux/module.h>
-#include <linux/cdev.h>            /* struct cdev */
-#include <linux/kdev_t.h>          /* MKDEV() */
-#include <linux/fs.h>              /* register_chrdev_region() */
-#include <linux/device.h>          /* struct class */
 #include <linux/platform_device.h> /* platform_device() */
 #include <linux/err.h>             /* IS_ERR() */
 #include <linux/io.h>              /* ioremap() */
@@ -29,10 +28,10 @@
 #include <mach/dmm.h>
 
 #undef __DEBUG__
-#define BITS_32(in_NbBits) ((((u32)1 << in_NbBits) - 1) | ((u32)1 << in_NbBits))
-#define BITFIELD_32(in_UpBit, in_LowBit)\
-        (BITS_32(in_UpBit) & ~((BITS_32(in_LowBit)) >> 1))
-#define BF BITFIELD_32
+
+#define MASK(msb, lsb) (((1 << ((msb) + 1 - (lsb))) - 1) << (lsb))
+#define SET_FLD(reg, msb, lsb, val) \
+(((reg) & ~MASK((msb), (lsb))) | (((val) << (lsb)) & MASK((msb), (lsb))))
 
 #ifdef __DEBUG__
 #define DEBUG(x, y) printk(KERN_NOTICE "%s()::%d:%s=(0x%08x)\n", \
@@ -41,16 +40,6 @@
 #define DEBUG(x, y)
 #endif
 
-static s32 dmm_major;
-static s32 dmm_minor;
-
-struct dmm_dev {
-        struct cdev cdev;
-};
-
-static struct dmm_dev *dmm_device;
-static struct class *dmmdev_class;
-
 static struct platform_driver dmm_driver_ldm = {
         .driver = {
                 .owner = THIS_MODULE,
@@ -63,18 +52,15 @@ static struct platform_driver dmm_driver_ldm = {
 
 s32 dmm_pat_refill(struct dmm *dmm, struct pat *pd, enum pat_mode mode)
 {
-        void __iomem *r = NULL;
-        u32 v = -1, w = -1;
+        void __iomem *r;
+        u32 v;
 
         /* Only manual refill supported */
         if (mode != MANUAL)
                 return -EFAULT;
 
-        /*
-         * Check that the DMM_PAT_STATUS register
-         * has not reported an error.
-        */
-        r = (void __iomem *)((u32)dmm->base | DMM_PAT_STATUS__0);
+        /* Check that the DMM_PAT_STATUS register has not reported an error */
+        r = dmm->base + DMM_PAT_STATUS__0;
         v = __raw_readl(r);
         if ((v & 0xFC00) != 0) {
                 while (1)
@@ -82,28 +68,19 @@ s32 dmm_pat_refill(struct dmm *dmm, struct pat *pd, enum pat_mode mode)
         }
 
         /* Set "next" register to NULL */
-        r = (void __iomem *)((u32)dmm->base | DMM_PAT_DESCR__0);
+        r = dmm->base + DMM_PAT_DESCR__0;
         v = __raw_readl(r);
-        w = (v & (~(BF(31, 4)))) | ((((u32)NULL) << 4) & BF(31, 4));
-        __raw_writel(w, r);
+        v = SET_FLD(v, 31, 4, (u32) NULL);
+        __raw_writel(v, r);
 
         /* Set area to be refilled */
-        r = (void __iomem *)((u32)dmm->base | DMM_PAT_AREA__0);
-        v = __raw_readl(r);
-        w = (v & (~(BF(30, 24)))) | ((((s8)pd->area.y1) << 24) & BF(30, 24));
-        __raw_writel(w, r);
-
-        v = __raw_readl(r);
-        w = (v & (~(BF(23, 16)))) | ((((s8)pd->area.x1) << 16) & BF(23, 16));
-        __raw_writel(w, r);
-
-        v = __raw_readl(r);
-        w = (v & (~(BF(14, 8)))) | ((((s8)pd->area.y0) << 8) & BF(14, 8));
-        __raw_writel(w, r);
-
+        r = dmm->base + DMM_PAT_AREA__0;
         v = __raw_readl(r);
-        w = (v & (~(BF(7, 0)))) | ((((s8)pd->area.x0) << 0) & BF(7, 0));
-        __raw_writel(w, r);
+        v = SET_FLD(v, 30, 24, pd->area.y1);
+        v = SET_FLD(v, 23, 16, pd->area.x1);
+        v = SET_FLD(v, 14, 8, pd->area.y0);
+        v = SET_FLD(v, 7, 0, pd->area.x0);
+        __raw_writel(v, r);
         wmb();
 
 #ifdef __DEBUG__
@@ -115,92 +92,71 @@ s32 dmm_pat_refill(struct dmm *dmm, struct pat *pd, enum pat_mode mode)
 #endif
 
         /* First, clear the DMM_PAT_IRQSTATUS register */
-        r = (void __iomem *)((u32)dmm->base | (u32)DMM_PAT_IRQSTATUS);
+        r = dmm->base + DMM_PAT_IRQSTATUS;
         __raw_writel(0xFFFFFFFF, r);
         wmb();
 
-        r = (void __iomem *)((u32)dmm->base | (u32)DMM_PAT_IRQSTATUS_RAW);
-        v = 0xFFFFFFFF;
-
-        while (v != 0x0) {
+        r = dmm->base + DMM_PAT_IRQSTATUS_RAW;
+        do {
                 v = __raw_readl(r);
                 DEBUG("DMM_PAT_IRQSTATUS_RAW", v);
-        }
+        } while (v != 0x0);
 
         /* Fill data register */
-        r = (void __iomem *)((u32)dmm->base | DMM_PAT_DATA__0);
+        r = dmm->base + DMM_PAT_DATA__0;
         v = __raw_readl(r);
 
-        /* Apply 4 bit left shft to counter the 4 bit right shift */
-        w = (v & (~(BF(31, 4)))) | ((((u32)(pd->data >> 4)) << 4) & BF(31, 4));
-        __raw_writel(w, r);
+        /* pd->data must be 16 aligned */
+        BUG_ON(pd->data & 15);
+        v = SET_FLD(v, 31, 4, pd->data >> 4);
+        __raw_writel(v, r);
         wmb();
 
         /* Read back PAT_DATA__0 to see if write was successful */
-        v = 0x0;
-        while (v != pd->data) {
+        do {
                 v = __raw_readl(r);
                 DEBUG("DMM_PAT_DATA__0", v);
-        }
-
-        r = (void __iomem *)((u32)dmm->base | (u32)DMM_PAT_CTRL__0);
-        v = __raw_readl(r);
-
-        w = (v & (~(BF(31, 28)))) | ((((u32)pd->ctrl.ini) << 28) & BF(31, 28));
-        __raw_writel(w, r);
-
-        v = __raw_readl(r);
-        w = (v & (~(BF(16, 16)))) | ((((u32)pd->ctrl.sync) << 16) & BF(16, 16));
-        __raw_writel(w, r);
-
-        v = __raw_readl(r);
-        w = (v & (~(BF(9, 8)))) | ((((u32)pd->ctrl.lut_id) << 8) & BF(9, 8));
-        __raw_writel(w, r);
-
-        v = __raw_readl(r);
-        w = (v & (~(BF(6, 4)))) | ((((u32)pd->ctrl.dir) << 4) & BF(6, 4));
-        __raw_writel(w, r);
+        } while (v != pd->data);
 
+        r = dmm->base + DMM_PAT_CTRL__0;
         v = __raw_readl(r);
-        w = (v & (~(BF(0, 0)))) | ((((u32)pd->ctrl.start) << 0) & BF(0, 0));
-        __raw_writel(w, r);
+        v = SET_FLD(v, 31, 28, pd->ctrl.ini);
+        v = SET_FLD(v, 16, 16, pd->ctrl.sync);
+        v = SET_FLD(v, 9, 8, pd->ctrl.lut_id);
+        v = SET_FLD(v, 6, 4, pd->ctrl.dir);
+        v = SET_FLD(v, 0, 0, pd->ctrl.start);
+        __raw_writel(v, r);
         wmb();
 
-        /*
-         * Now, check if PAT_IRQSTATUS_RAW has been
-         * set after the PAT has been refilled
-         */
-        r = (void __iomem *)((u32)dmm->base | (u32)DMM_PAT_IRQSTATUS_RAW);
-        v = 0x0;
-        while ((v & 0x3) != 0x3) {
+        /* Check if PAT_IRQSTATUS_RAW is set after the PAT has been refilled */
+        r = dmm->base + DMM_PAT_IRQSTATUS_RAW;
+        do {
                 v = __raw_readl(r);
                 DEBUG("DMM_PAT_IRQSTATUS_RAW", v);
-        }
+        } while ((v & 0x3) != 0x3);
 
         /* Again, clear the DMM_PAT_IRQSTATUS register */
-        r = (void __iomem *)((u32)dmm->base | (u32)DMM_PAT_IRQSTATUS);
+        r = dmm->base + DMM_PAT_IRQSTATUS;
         __raw_writel(0xFFFFFFFF, r);
         wmb();
 
-        r = (void __iomem *)((u32)dmm->base | (u32)DMM_PAT_IRQSTATUS_RAW);
-        v = 0xFFFFFFFF;
-
-        while (v != 0x0) {
+        r = dmm->base + DMM_PAT_IRQSTATUS_RAW;
+        do {
                 v = __raw_readl(r);
                 DEBUG("DMM_PAT_IRQSTATUS_RAW", v);
-        }
+        } while (v != 0x0);
 
         /* Again, set "next" register to NULL to clear any PAT STATUS errors */
-        r = (void __iomem *)((u32)dmm->base | DMM_PAT_DESCR__0);
+        r = dmm->base + DMM_PAT_DESCR__0;
         v = __raw_readl(r);
-        w = (v & (~(BF(31, 4)))) | ((((u32)NULL) << 4) & BF(31, 4));
-        __raw_writel(w, r);
+        v = SET_FLD(v, 31, 4, (u32) NULL);
+        __raw_writel(v, r);
 
         /*
          * Now, check that the DMM_PAT_STATUS register
          * has not reported an error before exiting.
         */
-        r = (void __iomem *)((u32)dmm->base | DMM_PAT_STATUS__0);
+        r = dmm->base + DMM_PAT_STATUS__0;
         v = __raw_readl(r);
         if ((v & 0xFC00) != 0) {
                 while (1)
@@ -211,25 +167,10 @@ s32 dmm_pat_refill(struct dmm *dmm, struct pat *pd, enum pat_mode mode)
 }
 EXPORT_SYMBOL(dmm_pat_refill);
 
-static s32 dmm_open(struct inode *ip, struct file *filp)
-{
-        return 0;
-}
-
-static s32 dmm_release(struct inode *ip, struct file *filp)
-{
-        return 0;
-}
-
-static const struct file_operations dmm_fops = {
-        .open    = dmm_open,
-        .release = dmm_release,
-};
-
 struct dmm *dmm_pat_init(u32 id)
 {
-        u32 base = 0;
-        struct dmm *dmm = NULL;
+        u32 base;
+        struct dmm *dmm;
         switch (id) {
         case 0:
                 /* only support id 0 for now */
@@ -276,60 +217,16 @@ EXPORT_SYMBOL(dmm_pat_release);
 
 static s32 __init dmm_init(void)
 {
-        dev_t dev  = 0;
-        s32 r = -1;
-        struct device *device = NULL;
-
-        if (dmm_major) {
-                dev = MKDEV(dmm_major, dmm_minor);
-                r = register_chrdev_region(dev, 1, "dmm");
-        } else {
-                r = alloc_chrdev_region(&dev, dmm_minor, 1, "dmm");
-                dmm_major = MAJOR(dev);
-        }
-
-        dmm_device = kmalloc(sizeof(*dmm_device), GFP_KERNEL);
-        if (!dmm_device) {
-                unregister_chrdev_region(dev, 1);
-                return -ENOMEM;
-        }
-        memset(dmm_device, 0x0, sizeof(struct dmm_dev));
-
-        cdev_init(&dmm_device->cdev, &dmm_fops);
-        dmm_device->cdev.owner = THIS_MODULE;
-        dmm_device->cdev.ops = &dmm_fops;
-
-        r = cdev_add(&dmm_device->cdev, dev, 1);
-        if (r)
-                printk(KERN_ERR "cdev_add():failed\n");
-
-        dmmdev_class = class_create(THIS_MODULE, "dmm");
-
-        if (IS_ERR(dmmdev_class)) {
-                printk(KERN_ERR "class_create():failed\n");
-                goto EXIT;
-        }
-
-        device = device_create(dmmdev_class, NULL, dev, NULL, "dmm");
-        if (device == NULL)
-                printk(KERN_ERR "device_create() fail\n");
-
-        r = platform_driver_register(&dmm_driver_ldm);
-
-EXIT:
-        return r;
+        return platform_driver_register(&dmm_driver_ldm);
 }
 
 static void __exit dmm_exit(void)
 {
         platform_driver_unregister(&dmm_driver_ldm);
-        cdev_del(&dmm_device->cdev);
-        kfree(dmm_device);
-        device_destroy(dmmdev_class, MKDEV(dmm_major, dmm_minor));
-        class_destroy(dmmdev_class);
 }
 
 MODULE_LICENSE("GPL v2");
 MODULE_AUTHOR("davidsin@ti.com");
+MODULE_AUTHOR("molnar@ti.com");
 module_init(dmm_init);
 module_exit(dmm_exit);
diff --git a/drivers/media/video/tiler/tcm.h b/drivers/media/video/tiler/tcm.h
index ccd3ce4eaaa..abeb99b6697 100644
--- a/drivers/media/video/tiler/tcm.h
+++ b/drivers/media/video/tiler/tcm.h
@@ -4,6 +4,8 @@
  * TILER container manager specification and support functions for TI
  * processors.
  *
+ * Author: Lajos Molnar <molnar@ti.com>
+ *
  * Copyright (C) 2009-2010 Texas Instruments, Inc.
  *
  * This package is free software; you can redistribute it and/or modify
@@ -15,19 +17,18 @@
  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  */
 
-#ifndef _TCM_H_
-#define _TCM_H_
-
-#include <linux/init.h>
-#include <linux/module.h>
+#ifndef TCM_H
+#define TCM_H
 
 struct tcm;
 
+/* point */
 struct tcm_pt {
         u16 x;
         u16 y;
 };
 
+/* 1d or 2d area */
 struct tcm_area {
         bool is2d;              /* whether are is 1d or 2d */
         struct tcm    *tcm;     /* parent */
@@ -90,8 +91,6 @@ struct tcm *name(u16 width, u16 height, typeof(attr_t) *attr);
 /**
  * Deinitialize tiler container manager.
  *
- * @author Ravi Ramachandra (3/1/2010)
- *
  * @param tcm   Pointer to container manager.
  *
  * @return 0 on success, non-0 error value on error.  The call
@@ -108,8 +107,6 @@ static inline void tcm_deinit(struct tcm *tcm)
 /**
  * Reserves a 2D area in the container.
  *
- * @author Ravi Ramachandra (3/1/2010)
- *
  * @param tcm           Pointer to container manager.
  * @param height        Height(in pages) of area to be reserved.
  * @param width         Width(in pages) of area to be reserved.
@@ -129,13 +126,17 @@ static inline s32 tcm_reserve_2d(struct tcm *tcm, u16 width, u16 height,
                                  u16 align, struct tcm_area *area)
 {
         /* perform rudimentary error checking */
-        s32 res = (tcm  == NULL ? -ENODEV :
-                   area == NULL ? -EINVAL :
-                   (height > tcm->height || width > tcm->width) ? -ENOMEM :
-                   tcm->reserve_2d(tcm, height, width, align, area));
-
-        if (area)
+        s32 res = tcm  == NULL ? -ENODEV :
+                (area == NULL || width == 0 || height == 0 ||
+                 /* align must be a 2 power */
+                 align & (align - 1)) ? -EINVAL :
+                (height > tcm->height || width > tcm->width) ? -ENOMEM : 0;
+
+        if (!res) {
+                area->is2d = true;
+                res = tcm->reserve_2d(tcm, height, width, align, area);
                 area->tcm = res ? NULL : tcm;
+        }
 
         return res;
 }
@@ -143,8 +144,6 @@ static inline s32 tcm_reserve_2d(struct tcm *tcm, u16 width, u16 height,
 /**
  * Reserves a 1D area in the container.
  *
- * @author Ravi Ramachandra (3/1/2010)
- *
  * @param tcm           Pointer to container manager.
  * @param slots         Number of (contiguous) slots to reserve.
  * @param area          Pointer to where the reserved area should be stored.
@@ -159,13 +158,15 @@ static inline s32 tcm_reserve_1d(struct tcm *tcm, u32 slots,
                                  struct tcm_area *area)
 {
         /* perform rudimentary error checking */
-        s32 res = (tcm  == NULL ? -ENODEV :
-                   area == NULL ? -EINVAL :
-                   slots > (tcm->width * (u32) tcm->height) ? -ENOMEM :
-                   tcm->reserve_1d(tcm, slots, area));
+        s32 res = tcm  == NULL ? -ENODEV :
+                (area == NULL || slots == 0) ? -EINVAL :
+                slots > (tcm->width * (u32) tcm->height) ? -ENOMEM : 0;
 
-        if (area)
+        if (!res) {
+                area->is2d = false;
+                res = tcm->reserve_1d(tcm, slots, area);
                 area->tcm = res ? NULL : tcm;
+        }
 
         return res;
 }
@@ -173,8 +174,6 @@ static inline s32 tcm_reserve_1d(struct tcm *tcm, u32 slots,
 /**
  * Free a previously reserved area from the container.
  *
- * @author Ravi Ramachandra (3/1/2010)
- *
  * @param area  Pointer to area reserved by a prior call to
  *              tcm_reserve_1d or tcm_reserve_2d call, whether
  *              it was successful or not. (Note: all fields of
@@ -209,8 +208,6 @@ static inline s32 tcm_free(struct tcm_area *area)
  * fit in a 2D slice, its tcm pointer is set to NULL to mark that it is no
  * longer a valid area.
  *
- * @author Lajos Molnar (3/17/2010)
- *
  * @param parent        Pointer to a VALID parent area that will get modified
  * @param slice         Pointer to the slice area that will get modified
  */
@@ -234,16 +231,10 @@ static inline void tcm_slice(struct tcm_area *parent, struct tcm_area *slice)
         }
 }
 
-/**
- * Verifies if a tcm area is logically valid.
- *
- * @param area          Pointer to tcm area
- *
- * @return TRUE if area is logically valid, FALSE otherwise.
- */
+/* Verify if a tcm area is logically valid */
 static inline bool tcm_area_is_valid(struct tcm_area *area)
 {
-        return (area && area->tcm &&
+        return area && area->tcm &&
                 /* coordinate bounds */
                 area->p1.x < area->tcm->width &&
                 area->p1.y < area->tcm->height &&
@@ -255,8 +246,7 @@ static inline bool tcm_area_is_valid(struct tcm_area *area)
                   area->p1.x + area->p1.y * area->tcm->width) ||
                  /* 2D coordinate relationship */
                  (area->is2d &&
-                  area->p0.x <= area->p1.x))
-               );
+                  area->p0.x <= area->p1.x));
 }
 
 /* see if a coordinate is within an area */
@@ -316,4 +306,4 @@ static inline u16 __tcm_sizeof(struct tcm_area *area)
              tcm_slice(&safe, &var); \
              var.tcm; tcm_slice(&safe, &var))
 
-#endif /* _TCM_H_ */
+#endif
diff --git a/drivers/media/video/tiler/tcm/tcm-utils.h b/drivers/media/video/tiler/tcm/tcm-utils.h
index 1013929a455..0d1260af197 100644
--- a/drivers/media/video/tiler/tcm/tcm-utils.h
+++ b/drivers/media/video/tiler/tcm/tcm-utils.h
@@ -3,6 +3,8 @@
  *
  * Utility functions for implementing TILER container managers.
  *
+ * Author: Lajos Molnar <molnar@ti.com>
+ *
  * Copyright (C) 2009-2010 Texas Instruments, Inc.
  *
  * This package is free software; you can redistribute it and/or modify
@@ -14,19 +16,17 @@
  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  */
 
-#ifndef _TCM_UTILS_H
-#define _TCM_UTILS_H
+#ifndef TCM_UTILS_H
+#define TCM_UTILS_H
 
 #include "../tcm.h"
 
-#define AREA_FMT   "(%03d %03d)-(%03d %03d)"
-#define AREA(area) (area).p0.x, (area).p0.y, (area).p1.x, (area).p1.y
-
 /* TCM_ALG_NAME must be defined to use the debug methods */
 
 #ifdef DEBUG
 #define IFDEBUG(x) x
 #else
+/* compile-check debug statements even if not DEBUG */
 #define IFDEBUG(x) do { if (0) x; } while (0)
 #endif
 
@@ -38,7 +38,8 @@
 #define P2(fmt, ...) P(KERN_INFO, fmt, ##__VA_ARGS__)
 #define P3(fmt, ...) P(KERN_DEBUG, fmt, ##__VA_ARGS__)
 
-#define PA(level, msg, p_area) P##level(msg " " AREA_FMT "\n", AREA(*(p_area)))
+#define PA(level, msg, p_area) P##level(msg " (%03d %03d)-(%03d %03d)\n", \
+        (p_area)->p0.x, (p_area)->p0.y, (p_area)->p1.x, (p_area)->p1.y)
 
 /* assign coordinates to area */
 static inline
@@ -50,10 +51,4 @@ void assign(struct tcm_area *a, u16 x0, u16 y0, u16 x1, u16 y1)
         a->p1.y = y1;
 }
 
-static inline
-void dump_area(struct tcm_area *area)
-{
-        printk(KERN_NOTICE AREA_FMT "\n", AREA(*area));
-}
-
 #endif
diff --git a/drivers/media/video/tiler/tmm-pat.c b/drivers/media/video/tiler/tmm-pat.c
index c3c86e582db..0e50fa35912 100644
--- a/drivers/media/video/tiler/tmm-pat.c
+++ b/drivers/media/video/tiler/tmm-pat.c
@@ -3,6 +3,8 @@
  *
  * DMM driver support functions for TI OMAP processors.
  *
+ * Author: Lajos Molnar <molnar@ti.com>, David Sin <dsin@ti.com>
+ *
  * Copyright (C) 2009-2010 Texas Instruments, Inc.
  *
  * This package is free software; you can redistribute it and/or modify
@@ -24,246 +26,195 @@
 
 #include "tmm.h"
 
-/**
- * Number of pages to allocate when
- * refilling the free page stack.
- */
-#define MAX 16
-#define DMM_PAGE 0x1000
-
-/* Max pages in free page stack */
-#define PAGE_CAP (256 * 40)
+/* Memory limit to cache free pages. TILER will eventually use this much */
+static u32 cache_limit = (40 * 1024 * 1024);
+module_param_named(cache, cache_limit, uint, 0644);
+MODULE_PARM_DESC(cache, "Cache free pages if total memory is under this limit");
 
-/* Number of pages currently allocated */
-static unsigned long count;
+/* global state - statically initialized */
+static LIST_HEAD(free_list);    /* page cache: list of free pages */
+static u32 total_mem;           /* total memory allocated (free & used) */
+static u32 refs;                /* number of tmm_pat instances */
+static DEFINE_MUTEX(mtx);       /* global mutex */
 
-/**
-  * Used to keep track of mem per
-  * dmm_get_pages call.
-  */
-struct fast {
+/* The page struct pointer and physical address of each page.*/
+struct mem {
         struct list_head list;
-        struct mem **mem;
-        u32 *pa;
-        u32 num;
+        struct page *pg;        /* page struct */
+        u32 pa;                 /* physical address */
 };
 
-/**
- * Used to keep track of the page struct ptrs
- * and physical addresses of each page.
- */
-struct mem {
+/* Used to keep track of mem per tmm_pat_get_pages call */
+struct fast {
         struct list_head list;
-        struct page *pg;
-        u32 pa;
+        struct mem **mem;       /* array of page info */
+        u32 *pa;                /* array of physical addresses */
+        u32 num;                /* number of pages */
 };
 
-/**
- * TMM PAT private structure
- */
+/* TMM PAT private structure */
 struct dmm_mem {
-        struct fast fast_list;
-        struct mem free_list;
-        struct mem used_list;
-        struct mutex mtx;
+        struct list_head fast_list;
         struct dmm *dmm;
 };
 
-static void dmm_free_fast_list(struct fast *fast)
+/**
+ *  Frees pages in a fast structure.  Moves pages to the free list if there
+ *  are less pages used than max_to_keep.  Otherwise, it frees the pages
+ */
+static void free_fast(struct fast *f)
 {
-        struct list_head *pos = NULL, *q = NULL;
-        struct fast *f = NULL;
         s32 i = 0;
 
         /* mutex is locked */
-        list_for_each_safe(pos, q, &fast->list) {
-                f = list_entry(pos, struct fast, list);
-                for (i = 0; i < f->num; i++)
+        for (i = 0; i < f->num; i++) {
+                if (total_mem < cache_limit) {
+                        /* cache free page if under the limit */
+                        list_add(&f->mem[i]->list, &free_list);
+                } else {
+                        /* otherwise, free */
+                        total_mem -= PAGE_SIZE;
                         __free_page(f->mem[i]->pg);
-                kfree(f->pa);
-                kfree(f->mem);
-                list_del(pos);
-                kfree(f);
+                }
         }
+        kfree(f->pa);
+        kfree(f->mem);
+        /* remove only if element was added */
+        if (f->list.next)
+                list_del(&f->list);
+        kfree(f);
 }
 
-static u32 fill_page_stack(struct mem *mem, struct mutex *mtx)
+/* allocate and flush a page */
+static struct mem *alloc_mem(void)
 {
-        s32 i = 0;
-        struct mem *m = NULL;
-
-        for (i = 0; i < MAX; i++) {
-                m = kmalloc(sizeof(*m), GFP_KERNEL);
-                if (!m)
-                        return -ENOMEM;
-                memset(m, 0x0, sizeof(*m));
-
-                m->pg = alloc_page(GFP_KERNEL | GFP_DMA);
-                if (!m->pg) {
-                        kfree(m);
-                        return -ENOMEM;
-                }
+        struct mem *m = kmalloc(sizeof(*m), GFP_KERNEL);
+        if (!m)
+                return NULL;
+        memset(m, 0, sizeof(*m));
 
-                m->pa = page_to_phys(m->pg);
+        m->pg = alloc_page(GFP_KERNEL | GFP_DMA);
+        if (!m->pg) {
+                kfree(m);
+                return NULL;
+        }
 
-                /**
-                 * Note: we need to flush the cache
-                 * entry for each page we allocate.
-                */
-                dmac_flush_range((void *)page_address(m->pg),
-                                        (void *)page_address(m->pg) + DMM_PAGE);
-                outer_flush_range(m->pa, m->pa + DMM_PAGE);
+        m->pa = page_to_phys(m->pg);
 
-                mutex_lock(mtx);
-                count++;
-                list_add(&m->list, &mem->list);
-                mutex_unlock(mtx);
-        }
-        return 0x0;
+        /* flush the cache entry for each page we allocate. */
+        dmac_flush_range(page_address(m->pg),
+                                page_address(m->pg) + PAGE_SIZE);
+        outer_flush_range(m->pa, m->pa + PAGE_SIZE);
+
+        return m;
 }
 
-static void dmm_free_page_stack(struct mem *mem)
+static void free_page_cache(void)
 {
-        struct list_head *pos = NULL, *q = NULL;
-        struct mem *m = NULL;
+        struct mem *m, *m_;
 
         /* mutex is locked */
-        list_for_each_safe(pos, q, &mem->list) {
-                m = list_entry(pos, struct mem, list);
+        list_for_each_entry_safe(m, m_, &free_list, list) {
                 __free_page(m->pg);
-                list_del(pos);
+                total_mem -= PAGE_SIZE;
+                list_del(&m->list);
                 kfree(m);
         }
 }
 
 static void tmm_pat_deinit(struct tmm *tmm)
 {
+        struct fast *f, *f_;
         struct dmm_mem *pvt = (struct dmm_mem *) tmm->pvt;
 
-        mutex_lock(&pvt->mtx);
-        dmm_free_fast_list(&pvt->fast_list);
-        dmm_free_page_stack(&pvt->free_list);
-        dmm_free_page_stack(&pvt->used_list);
-        mutex_destroy(&pvt->mtx);
+        mutex_lock(&mtx);
+
+        /* free all outstanding used memory */
+        list_for_each_entry_safe(f, f_, &pvt->fast_list, list)
+                free_fast(f);
+
+        /* if this is the last tmm_pat, free all memory */
+        if (--refs == 0)
+                free_page_cache();
+
+        mutex_unlock(&mtx);
 }
 
-static u32 *tmm_pat_get_pages(struct tmm *tmm, s32 n)
+static u32 *tmm_pat_get_pages(struct tmm *tmm, u32 n)
 {
-        s32 i = 0;
-        struct list_head *pos = NULL, *q = NULL;
-        struct mem *m = NULL;
-        struct fast *f = NULL;
+        struct mem *m;
+        struct fast *f;
         struct dmm_mem *pvt = (struct dmm_mem *) tmm->pvt;
 
-        if (n <= 0 || n > 0x8000)
-                return NULL;
-
-        if (list_empty_careful(&pvt->free_list.list))
-                if (fill_page_stack(&pvt->free_list, &pvt->mtx))
-                        return NULL;
-
         f = kmalloc(sizeof(*f), GFP_KERNEL);
         if (!f)
                 return NULL;
-        memset(f, 0x0, sizeof(*f));
+        memset(f, 0, sizeof(*f));
 
         /* array of mem struct pointers */
         f->mem = kmalloc(n * sizeof(*f->mem), GFP_KERNEL);
-        if (!f->mem) {
-                kfree(f); return NULL;
-        }
-        memset(f->mem, 0x0, n * sizeof(*f->mem));
 
         /* array of physical addresses */
         f->pa = kmalloc(n * sizeof(*f->pa), GFP_KERNEL);
-        if (!f->pa) {
-                kfree(f->mem); kfree(f); return NULL;
-        }
-        memset(f->pa, 0x0, n * sizeof(*f->pa));
 
-        /*
-         * store the number of mem structs so that we
-         * know how many to free later.
-         */
-        f->num = n;
-
-        for (i = 0; i < n; i++) {
-                if (list_empty_careful(&pvt->free_list.list))
-                        if (fill_page_stack(&pvt->free_list, &pvt->mtx))
+        /* no pages have been allocated yet (needed for cleanup) */
+        f->num = 0;
+
+        if (!f->mem || !f->pa)
+                goto cleanup;
+
+        memset(f->mem, 0, n * sizeof(*f->mem));
+        memset(f->pa, 0, n * sizeof(*f->pa));
+
+        /* fill out fast struct mem array with free pages */
+        mutex_lock(&mtx);
+        while (f->num < n) {
+                /* if there is a free cached page use it */
+                if (!list_empty(&free_list)) {
+                        /* unbind first element from list */
+                        m = list_first_entry(&free_list, typeof(*m), list);
+                        list_del(&m->list);
+                } else {
+                        mutex_unlock(&mtx);
+
+                        /**
+                         * Unlock mutex during allocation and cache flushing.
+                         */
+                        m = alloc_mem();
+                        if (!m)
                                 goto cleanup;
 
-                mutex_lock(&pvt->mtx);
-                pos = NULL;
-                q = NULL;
-
-                /*
-                 * remove one mem struct from the free list and
-                 * add the address to the fast struct mem array
-                 */
-                list_for_each_safe(pos, q, &pvt->free_list.list) {
-                        m = list_entry(pos, struct mem, list);
-                        f->mem[i] = m;
-                        list_del(pos);
-                        break;
+                        mutex_lock(&mtx);
+                        total_mem += PAGE_SIZE;
                 }
-                mutex_unlock(&pvt->mtx);
 
-                if (m != NULL)
-                        f->pa[i] = m->pa;
-                else
-                        goto cleanup;
+                f->mem[f->num] = m;
+                f->pa[f->num++] = m->pa;
         }
 
-        mutex_lock(&pvt->mtx);
-        list_add(&f->list, &pvt->fast_list.list);
-        mutex_unlock(&pvt->mtx);
+        list_add(&f->list, &pvt->fast_list);
+        mutex_unlock(&mtx);
+        return f->pa;
 
-        if (f != NULL)
-                return f->pa;
 cleanup:
-        for (; i > 0; i--) {
-                mutex_lock(&pvt->mtx);
-                list_add(&f->mem[i - 1]->list, &pvt->free_list.list);
-                mutex_unlock(&pvt->mtx);
-        }
-        kfree(f->pa);
-        kfree(f->mem);
-        kfree(f);
+        free_fast(f);
         return NULL;
 }
 
-static void tmm_pat_free_pages(struct tmm *tmm, u32 *list)
+static void tmm_pat_free_pages(struct tmm *tmm, u32 *page_list)
 {
         struct dmm_mem *pvt = (struct dmm_mem *) tmm->pvt;
-        struct list_head *pos = NULL, *q = NULL;
-        struct fast *f = NULL;
-        s32 i = 0;
+        struct fast *f, *f_;
 
-        mutex_lock(&pvt->mtx);
-        pos = NULL;
-        q = NULL;
-        list_for_each_safe(pos, q, &pvt->fast_list.list) {
-                f = list_entry(pos, struct fast, list);
-                if (f->pa[0] == list[0]) {
-                        for (i = 0; i < f->num; i++) {
-                                if (count < PAGE_CAP) {
-                                        list_add(
-                                        &((struct mem *)f->mem[i])->list,
-                                        &pvt->free_list.list);
-                                } else {
-                                        __free_page(
-                                                ((struct mem *)f->mem[i])->pg);
-                                        count--;
-                                }
-                        }
-                        list_del(pos);
-                        kfree(f->pa);
-                        kfree(f->mem);
-                        kfree(f);
+        mutex_lock(&mtx);
+        /* find fast struct based on 1st page */
+        list_for_each_entry_safe(f, f_, &pvt->fast_list, list) {
+                if (f->pa[0] == page_list[0]) {
+                        free_fast(f);
                         break;
                 }
         }
-        mutex_unlock(&pvt->mtx);
+        mutex_unlock(&mtx);
 }
 
 static s32 tmm_pat_map(struct tmm *tmm, struct pat_area area, u32 page_pa)
@@ -298,15 +249,12 @@ struct tmm *tmm_pat_init(u32 pat_id)
         if (pvt) {
                 /* private data */
                 pvt->dmm = dmm;
-                INIT_LIST_HEAD(&pvt->free_list.list);
-                INIT_LIST_HEAD(&pvt->used_list.list);
-                INIT_LIST_HEAD(&pvt->fast_list.list);
-                mutex_init(&pvt->mtx);
+                INIT_LIST_HEAD(&pvt->fast_list);
 
-                count = 0;
-                if (list_empty_careful(&pvt->free_list.list))
-                        if (fill_page_stack(&pvt->free_list, &pvt->mtx))
-                                goto error;
+                /* increate tmm_pat references */
+                mutex_lock(&mtx);
+                refs++;
+                mutex_unlock(&mtx);
 
                 /* public data */
                 tmm->pvt = pvt;
@@ -319,7 +267,6 @@ struct tmm *tmm_pat_init(u32 pat_id)
                 return tmm;
         }
 
-error:
         kfree(pvt);
         kfree(tmm);
         dmm_pat_release(dmm);
diff --git a/drivers/media/video/tiler/tmm.h b/drivers/media/video/tiler/tmm.h
index 80d7001c14b..31470b3e44d 100644
--- a/drivers/media/video/tiler/tmm.h
+++ b/drivers/media/video/tiler/tmm.h
@@ -3,6 +3,8 @@
  *
  * TMM interface definition for TI TILER.
  *
+ * Author: Lajos Molnar <molnar@ti.com>
+ *
  * Copyright (C) 2009-2010 Texas Instruments, Inc.
  *
  * This package is free software; you can redistribute it and/or modify
@@ -24,7 +26,7 @@ struct tmm {
         void *pvt;
 
         /* function table */
-        u32 *(*get)     (struct tmm *tmm, s32 num_pages);
+        u32 *(*get)     (struct tmm *tmm, u32 num_pages);
         void (*free)    (struct tmm *tmm, u32 *pages);
         s32  (*map)     (struct tmm *tmm, struct pat_area area, u32 page_pa);
         void (*clear)   (struct tmm *tmm, struct pat_area area);
@@ -36,7 +38,7 @@ struct tmm {
  * @return a pointer to a list of physical page addresses.
  */
 static inline
-u32 *tmm_get(struct tmm *tmm, s32 num_pages)
+u32 *tmm_get(struct tmm *tmm, u32 num_pages)
 {
         if (tmm && tmm->pvt)
                 return tmm->get(tmm, num_pages);