TILER: Cleaned up tiler-iface.c and tiler.h, _tiler.h

Updated comments.
Simplified common expression when copying ioctl data.
Simplified block_info filling.
Removed unused variables, initializers, macros.
Fixed issue with registering buffer with no blocks.

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

TILER: Minor comment & code cleanup

Updated header comments.
Removed extranous headers.

Made ssptr_id flag read-only, as it should not be changed once tiler
is being used.

__analize_area now returns error values.
1D stride is explicitly set to 0 by describe.

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

9 files changed, 274 insertions, 259 deletions

diff --git a/arch/arm/mach-omap2/include/mach/dmm.h b/arch/arm/mach-omap2/include/mach/dmm.h
index 77f824d2a8c..68b798a22c4 100644
--- a/arch/arm/mach-omap2/include/mach/dmm.h
+++ b/arch/arm/mach-omap2/include/mach/dmm.h
@@ -1,7 +1,7 @@
 /*
  * dmm.h
  *
- * DMM driver support functions for TI OMAP processors.
+ * DMM driver support functions for TI DMM-TILER hardware block.
  *
  * Author: David Sin <davidsin@ti.com>
  *
diff --git a/arch/arm/mach-omap2/include/mach/tiler.h b/arch/arm/mach-omap2/include/mach/tiler.h
index a598fe51ffd..84452bc8944 100644
--- a/arch/arm/mach-omap2/include/mach/tiler.h
+++ b/arch/arm/mach-omap2/include/mach/tiler.h
@@ -1,7 +1,10 @@
 /*
  * tiler.h
  *
- * TILER driver support functions for TI OMAP processors.
+ * TILER driver support functions for TI TILER hardware block.
+ *
+ * Authors: Lajos Molnar <molnar@ti.com>
+ *          David Sin <davidsin@ti.com>
  *
  * Copyright (C) 2009-2010 Texas Instruments, Inc.
  *
@@ -17,8 +20,6 @@
 #ifndef TILER_H
 #define TILER_H
 
-#define TILER_MAX_NUM_BLOCKS 16
-
 #include <linux/mm.h>
 
 /*
@@ -40,27 +41,29 @@ enum tiler_fmt {
         TILFMT_8AND16  = 4,     /* used to mark NV12 reserve block */
 };
 
+/* tiler block info */
 struct tiler_block_t {
-        u32 phys;                       /* system space (L3) tiler addr */
-        u32 width;                      /* width */
-        u32 height;                     /* height */
-        u32 key;                        /* secret key */
-        u32 id;                         /* unique block ID */
+        u32 phys;               /* system space (L3) tiler addr */
+        u32 width;              /* width */
+        u32 height;             /* height */
+        u32 key;                /* secret key */
+        u32 id;                 /* unique block ID */
 };
 
+/* tiler (image/video frame) view */
 struct tiler_view_t {
-        u32 tsptr;                      /* tiler space addr */
-        u32 width;                      /* width */
-        u32 height;                     /* height */
-        u32 bpp;                        /* bytes per pixel */
-        s32 h_inc;                      /* horizontal increment */
-        s32 v_inc;                      /* vertical increment */
+        u32 tsptr;              /* tiler space addr */
+        u32 width;              /* width */
+        u32 height;             /* height */
+        u32 bpp;                /* bytes per pixel */
+        s32 h_inc;              /* horizontal increment */
+        s32 v_inc;              /* vertical increment */
 };
 
-/* get tiler format for a physical address */
+/* get the tiler format for a physical address or TILFMT_INVALID */
 enum tiler_fmt tiler_fmt(u32 phys);
 
-/* get tiler block bytes-per-pixel */
+/* get the modified (1 for page mode) bytes-per-pixel for a tiler block */
 u32 tiler_bpp(const struct tiler_block_t *b);
 
 /* get tiler block physical stride */
@@ -86,7 +89,7 @@ static inline u32 tiler_size(const struct tiler_block_t *b)
  *              must be 0) with the tiler block information. 'height' must be 1
  *              for 1D block.
  * @param fmt   TILER block format
- * @param align block alignment (default: PAGE_SIZE)
+ * @param align block alignment (default: normally PAGE_SIZE)
  * @param offs  block offset
  *
  * @return error status
@@ -101,8 +104,8 @@ s32 tiler_alloc(struct tiler_block_t *blk, enum tiler_fmt fmt, u32 align,
  * @param blk   pointer to tiler block data.  This must be set up ('phys' member
  *              must be 0) with the tiler block information. 'height' must be 1
  *              for 1D block.
- * @param fmt   TILER bit mode
- * @param align block alignment (default: PAGE_SIZE)
+ * @param fmt   TILER block format
+ * @param align block alignment (default: normally PAGE_SIZE)
  * @param offs  block offset
  * @param gid   group ID
  * @param pid   process ID
@@ -110,7 +113,7 @@ s32 tiler_alloc(struct tiler_block_t *blk, enum tiler_fmt fmt, u32 align,
  * @return error status
  */
 s32 tiler_allocx(struct tiler_block_t *blk, enum tiler_fmt fmt, u32 align,
-                u32 offs, u32 gid, pid_t pid);
+                                        u32 offs, u32 gid, pid_t pid);
 
 /**
  * Mmaps a portion of a tiler block to a virtual address.  Use this method in
@@ -120,7 +123,9 @@ s32 tiler_allocx(struct tiler_block_t *blk, enum tiler_fmt fmt, u32 align,
  * @param blk           pointer to tiler block data
  * @param offs          offset from where to map (must be page aligned)
  * @param size          size of area to map (must be page aligned)
- * @param addr          virtual address
+ * @param vma           VMM memory area to map to
+ * @param voffs         offset (from vm_start) in the VMM memory area to start
+ *                      mapping at
  *
  * @return error status
  */
@@ -136,11 +141,12 @@ s32 tiler_mmap_blk(struct tiler_block_t *blk, u32 offs, u32 size,
  * @param offs          offset from where to map (must be page aligned)
  * @param size          size of area to map (must be page aligned)
  * @param addr          virtual address
+ * @param mtype         ioremap memory type (e.g. MT_DEVICE)
  *
  * @return error status
  */
 s32 tiler_ioremap_blk(struct tiler_block_t *blk, u32 offs, u32 size, u32 addr,
-                      u32 mtype);
+                                                        u32 mtype);
 
 /**
  * Maps an existing buffer to a 1D or 2D TILER area for the
@@ -152,9 +158,9 @@ s32 tiler_ioremap_blk(struct tiler_block_t *blk, u32 offs, u32 size, u32 addr,
  * into tiler container.
  *
  * @param blk           pointer to tiler block data.  This must be set up
- *              ('phys' member must be 0) with the tiler block information.
- *              'height' must be 1 for 1D block.
- * @param fmt           TILER bit mode
+ *                      ('phys' member must be 0) with the tiler block
+ *                      information. 'height' must be 1 for 1D block.
+ * @param fmt           TILER format
  * @param usr_addr      user space address of existing buffer.
  *
  * @return error status
@@ -171,9 +177,9 @@ s32 tiler_map(struct tiler_block_t *blk, enum tiler_fmt fmt, u32 usr_addr);
  * into tiler container.
  *
  * @param blk           pointer to tiler block data.  This must be set up
- *              ('phys' member must be 0) with the tiler block information.
- *              'height' must be 1 for 1D block.
- * @param fmt           TILER bit mode
+ *                      ('phys' member must be 0) with the tiler block
+ *                      information. 'height' must be 1 for 1D block.
+ * @param fmt           TILER format
  * @param gid           group ID
  * @param pid           process ID
  * @param usr_addr      user space address of existing buffer.
@@ -181,7 +187,7 @@ s32 tiler_map(struct tiler_block_t *blk, enum tiler_fmt fmt, u32 usr_addr);
  * @return error status
  */
 s32 tiler_mapx(struct tiler_block_t *blk, enum tiler_fmt fmt,
-                u32 gid, pid_t pid, u32 usr_addr);
+                                        u32 gid, pid_t pid, u32 usr_addr);
 
 /**
  * Frees TILER memory.  Since there may be multiple references for the same area
@@ -189,34 +195,30 @@ s32 tiler_mapx(struct tiler_block_t *blk, enum tiler_fmt fmt,
  * have been freed.
  *
  * @param blk   pointer to a tiler block data as filled by tiler_alloc,
- *              tiler_map or tiler_dup.  'phys' member will be set to 0 on
- *              success.
+ *              tiler_map or tiler_dup.  'phys' and 'id' members will be set to
+ *              0 on success.
  */
 void tiler_free(struct tiler_block_t *blk);
 
 /**
- * Reserves tiler area for n identical blocks for the current
- * process.  Use this method to get optimal placement of
- * multiple identical tiler blocks; however, it may not reserve
- * area if tiler_alloc is equally efficient.
+ * Reserves tiler area for n identical blocks for the current process.  Use this
+ * method to get optimal placement of multiple identical tiler blocks; however,
+ * it may not reserve area if tiler_alloc is equally efficient.
  *
  * @param n             number of identical set of blocks
- * @param fmt           TILER bit mode
+ * @param fmt           TILER format
  * @param width         block width
  * @param height        block height (must be 1 for 1D)
  * @param align         block alignment (default: PAGE_SIZE)
  * @param offs          block offset
- *
- * @return error status
  */
-s32 tiler_reserve(u32 n, enum tiler_fmt fmt, u32 width, u32 height,
-                  u32 align, u32 offs);
+void tiler_reserve(u32 n, enum tiler_fmt fmt, u32 width, u32 height, u32 align,
+                                                                u32 offs);
 
 /**
- * Reserves tiler area for n identical blocks.  Use this method
- * to get optimal placement of multiple identical tiler blocks;
- * however, it may not reserve area if tiler_alloc is equally
- * efficient.
+ * Reserves tiler area for n identical blocks.  Use this method to get optimal
+ * placement of multiple identical tiler blocks; however, it may not reserve
+ * area if tiler_alloc is equally efficient.
  *
  * @param n             number of identical set of blocks
  * @param fmt           TILER bit mode
@@ -226,33 +228,27 @@ s32 tiler_reserve(u32 n, enum tiler_fmt fmt, u32 width, u32 height,
  * @param offs          block offset
  * @param gid           group ID
  * @param pid           process ID
- *
- * @return error status
  */
-s32 tiler_reservex(u32 n, enum tiler_fmt fmt, u32 width, u32 height,
-                   u32 align, u32 offs, u32 gid, pid_t pid);
+void tiler_reservex(u32 n, enum tiler_fmt fmt, u32 width, u32 height,
+                                u32 align, u32 offs, u32 gid, pid_t pid);
 
 /**
- * Reserves tiler area for n identical NV12 blocks for the
- * current process.  Use this method to get optimal placement of
- * multiple identical NV12 tiler blocks; however, it may not
- * reserve area if tiler_alloc is equally efficient.
+ * Reserves tiler area for n identical NV12 blocks for the current process.  Use
+ * this method to get optimal placement of multiple identical NV12 tiler blocks;
+ * however, it may not reserve area if tiler_alloc is equally efficient.
  *
  * @param n             number of identical set of blocks
  * @param width         block width (Y)
  * @param height        block height (Y)
  * @param align         block alignment (default: PAGE_SIZE)
  * @param offs          block offset
- *
- * @return error status
  */
-s32 tiler_reserve_nv12(u32 n, u32 width, u32 height, u32 align, u32 offs);
+void tiler_reserve_nv12(u32 n, u32 width, u32 height, u32 align, u32 offs);
 
 /**
- * Reserves tiler area for n identical NV12 blocks.  Use this
- * method to get optimal placement of multiple identical NV12
- * tiler blocks; however, it may not reserve area if tiler_alloc
- * is equally efficient.
+ * Reserves tiler area for n identical NV12 blocks.  Use this method to get
+ * optimal placement of multiple identical NV12 tiler blocks; however, it may
+ * not reserve area if tiler_alloc is equally efficient.
  *
  * @param n             number of identical set of blocks
  * @param width         block width (Y)
@@ -261,18 +257,16 @@ s32 tiler_reserve_nv12(u32 n, u32 width, u32 height, u32 align, u32 offs);
  * @param offs          block offset
  * @param gid           group ID
  * @param pid           process ID
- *
- * @return error status
  */
-s32 tiler_reservex_nv12(u32 n, u32 width, u32 height, u32 align, u32 offs,
+void tiler_reservex_nv12(u32 n, u32 width, u32 height, u32 align, u32 offs,
                                                         u32 gid, pid_t pid);
 
 /**
  * Create a view based on a tiler address and width and height
  *
- * This method should only be used as a last resort, if tilview object cannot
- * be passed because of incoherence with other view 2D objects that must be
- * supported.
+ * This method should only be used as a last resort, e.g. if tilview object
+ * cannot be passed because of incoherence with other view 2D objects that must
+ * be supported.
  *
  * @param view          Pointer to a view where the information will be stored
  * @param ssptr         MUST BE a tiler address
@@ -333,6 +327,7 @@ s32 tilview_flip(struct tiler_view_t *view, bool flip_x, bool flip_y);
  * ---------------------------- IOCTL Definitions ----------------------------
  */
 
+/* ioctls */
 #define TILIOC_GBLK  _IOWR('z', 100, struct tiler_block_info)
 #define TILIOC_FBLK   _IOW('z', 101, struct tiler_block_info)
 #define TILIOC_GSSP  _IOWR('z', 102, u32)
@@ -350,23 +345,26 @@ struct area {
         u16 height;
 };
 
+/* userspace tiler block info */
 struct tiler_block_info {
         enum tiler_fmt fmt;
         union {
                 struct area area;
                 u32 len;
         } dim;
-        u32 stride;
-        void *ptr;
+        u32 stride;     /* stride is not maintained for 1D blocks */
+        void *ptr;      /* userspace address for mapping existing buffer */
         u32 id;
         u32 key;
         u32 group_id;
-        /* alignment requirements for ssptr: ssptr & (align - 1) == offs */
-        u32 align;
-        u32 offs;
-        u32 ssptr;
+        u32 align;      /* alignment requirements for ssptr */
+        u32 offs;       /* offset (ssptr & (align - 1) will equal offs) */
+        u32 ssptr;      /* physical address, may not exposed by default */
 };
 
+#define TILER_MAX_NUM_BLOCKS 16
+
+/* userspace tiler buffer info */
 struct tiler_buf_info {
         u32 num_blocks;
         struct tiler_block_info blocks[TILER_MAX_NUM_BLOCKS];
@@ -374,6 +372,4 @@ struct tiler_buf_info {
         u32 length;     /* also used as number of buffers for reservation */
 };
 
-
 #endif
-
diff --git a/drivers/media/video/tiler/_tiler.h b/drivers/media/video/tiler/_tiler.h
index 24031348bf6..aeec9f6de6e 100644
--- a/drivers/media/video/tiler/_tiler.h
+++ b/drivers/media/video/tiler/_tiler.h
@@ -1,7 +1,9 @@
 /*
  * _tiler.h
  *
- * TILER driver internal shared definitions for TI OMAP processors.
+ * TI TILER driver internal shared definitions.
+ *
+ * Author: Lajos Molnar <molnar@ti.com>
  *
  * Copyright (C) 2009-2010 Texas Instruments, Inc.
  *
@@ -21,9 +23,6 @@
 #include <mach/tiler.h>
 #include "tcm.h"
 
-#define MIN(a, b) ((a) < (b) ? (a) : (b))
-#define MAX(a, b) ((a) > (b) ? (a) : (b))
-
 #define TILER_FORMATS           (TILFMT_MAX - TILFMT_MIN + 1)
 
 /* per process (thread group) info */
@@ -48,6 +47,7 @@ struct gid_info {
         struct process_info *pi;        /* parent */
 };
 
+/* info for an area reserved from a container */
 struct area_info {
         struct list_head by_gid;        /* areas in this pid/gid */
         struct list_head blocks;        /* blocks in this area */
@@ -57,6 +57,7 @@ struct area_info {
         struct gid_info *gi;            /* link to parent, if still alive */
 };
 
+/* info for a block */
 struct mem_info {
         struct list_head global;        /* reserved / global blocks */
         struct tiler_block_t blk;       /* block info */
@@ -72,6 +73,7 @@ struct mem_info {
         void *parent;                   /* area info for 2D, else group info */
 };
 
+/* tiler geometry information */
 struct tiler_geom {
         u32 x_shft;     /* unused X-bits (as part of bpp) */
         u32 y_shft;     /* unused Y-bits (as part of bpp) */
@@ -81,6 +83,7 @@ struct tiler_geom {
         u32 bpp_m;      /* modified bytes per pixel (=1 for page mode) */
 };
 
+/* methods and variables shared between source files */
 struct tiler_ops {
         /* block operations */
         s32 (*alloc) (enum tiler_fmt fmt, u32 width, u32 height,
@@ -93,7 +96,7 @@ struct tiler_ops {
         void (*reserve_nv12) (u32 n, u32 width, u32 height, u32 align, u32 offs,
                                         u32 gid, struct process_info *pi);
         void (*reserve) (u32 n, enum tiler_fmt fmt, u32 width, u32 height,
-                        u32 align, u32 offs, u32 gid, struct process_info *pi);
+                         u32 align, u32 offs, u32 gid, struct process_info *pi);
         void (*unreserve) (u32 gid, struct process_info *pi);
 
         /* block access operations */
@@ -103,8 +106,8 @@ struct tiler_ops {
         void (*unlock_free) (struct mem_info *mi, bool free);
 
         s32 (*lay_2d) (enum tiler_fmt fmt, u16 n, u16 w, u16 h, u16 band,
-                                u16 align, u16 offs, struct gid_info *gi,
-                                struct list_head *pos);
+                        u16 align, u16 offs, struct gid_info *gi,
+                        struct list_head *pos);
         s32 (*lay_nv12) (int n, u16 w, u16 w1, u16 h, struct gid_info *gi,
                                                                         u8 *p);
         /* group operations */
@@ -118,8 +121,8 @@ struct tiler_ops {
 
         /* area operations */
         s32 (*analize) (enum tiler_fmt fmt, u32 width, u32 height,
-                                  u16 *x_area, u16 *y_area, u16 *band,
-                                  u16 *align, u16 *offs, u16 *in_offs);
+                        u16 *x_area, u16 *y_area, u16 *band,
+                        u16 *align, u16 *offs, u16 *in_offs);
 
         /* process operations */
         void (*cleanup) (void);
diff --git a/drivers/media/video/tiler/dmm.c b/drivers/media/video/tiler/dmm.c
index 685a1935a7f..5ca5e7d5fa3 100644
--- a/drivers/media/video/tiler/dmm.c
+++ b/drivers/media/video/tiler/dmm.c
@@ -20,7 +20,6 @@
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/platform_device.h> /* platform_device() */
-#include <linux/err.h>             /* IS_ERR() */
 #include <linux/io.h>              /* ioremap() */
 #include <linux/errno.h>
 #include <linux/slab.h>
diff --git a/drivers/media/video/tiler/tcm.h b/drivers/media/video/tiler/tcm.h
index abeb99b6697..68b0d684dd5 100644
--- a/drivers/media/video/tiler/tcm.h
+++ b/drivers/media/video/tiler/tcm.h
@@ -2,7 +2,7 @@
  * tcm.h
  *
  * TILER container manager specification and support functions for TI
- * processors.
+ * TILER driver.
  *
  * Author: Lajos Molnar <molnar@ti.com>
  *
diff --git a/drivers/media/video/tiler/tiler-iface.c b/drivers/media/video/tiler/tiler-iface.c
index 688af6c8f71..a93cd486e09 100644
--- a/drivers/media/video/tiler/tiler-iface.c
+++ b/drivers/media/video/tiler/tiler-iface.c
@@ -1,7 +1,10 @@
 /*
  * tiler-iface.c
  *
- * TILER driver interace functions for TI OMAP processors.
+ * TILER driver interace functions for TI TILER hardware block.
+ *
+ * Authors: Lajos Molnar <molnar@ti.com>
+ *          David Sin <davidsin@ti.com>
  *
  * Copyright (C) 2009-2010 Texas Instruments, Inc.
  *
@@ -22,7 +25,7 @@
 #include <linux/sched.h>        /* current */
 #include <linux/mm.h>
 #include <linux/mm_types.h>
-#include <asm/mach/map.h>              /* for ioremap_page */
+#include <asm/mach/map.h>       /* for ioremap_page */
 
 #include "_tiler.h"
 
@@ -41,8 +44,8 @@ MODULE_PARM_DESC(offset_lookup,
         "Allow looking up a buffer by offset - This is a security risk");
 
 static struct mutex mtx;
-static struct list_head procs;
-static struct tiler_ops *ops;
+static struct list_head procs;  /* list of process info structs */
+static struct tiler_ops *ops;   /* shared methods and variables */
 
 /*
  *  Buffer handling methods
@@ -56,11 +59,10 @@ struct __buf_info {
 };
 
 /* check if an offset is used */
-/* must have mutex */
-/*** register_buf */
 static bool _m_offs_in_use(u32 offs, u32 length, struct process_info *pi)
 {
         struct __buf_info *_b;
+        /* have mutex */
         list_for_each_entry(_b, &pi->bufs, by_pid)
                 if (_b->buf_info.offset < offs + length &&
                     _b->buf_info.offset + _b->buf_info.length > offs)
@@ -69,8 +71,6 @@ static bool _m_offs_in_use(u32 offs, u32 length, struct process_info *pi)
 }
 
 /* get an offset */
-/* must have mutex */
-/*** register_buf */
 static u32 _m_get_offs(struct process_info *pi, u32 length)
 {
         static u32 offs = 0xda7a;
@@ -78,6 +78,8 @@ static u32 _m_get_offs(struct process_info *pi, u32 length)
         /* ensure no-one is using this offset */
         while ((offs << PAGE_SHIFT) + length < length ||
                _m_offs_in_use(offs << PAGE_SHIFT, length, pi)) {
+                /* use a pseudo-random generator to get a new offset to try */
+
                 /* Galois LSF: 20, 17 */
                 offs = (offs >> 1) ^ (u32)((0 - (offs & 1u)) & 0x90000);
         }
@@ -86,14 +88,15 @@ static u32 _m_get_offs(struct process_info *pi, u32 length)
 }
 
 /* find and lock a block.  process_info is optional */
-/* must have mutex */
 static struct mem_info *
 _m_lock_block(u32 key, u32 id, struct process_info *pi) {
-        struct gid_info *gi = NULL;
-        struct mem_info *mi = NULL;
+        struct gid_info *gi;
+        struct mem_info *mi;
 
         /* if process_info is given, look there first */
         if (pi) {
+                /* have mutex */
+
                 /* find block in process list and free it */
                 list_for_each_entry(gi, &pi->groups, by_pid) {
                         mi = ops->lock(key, id, gi);
@@ -107,15 +110,14 @@ _m_lock_block(u32 key, u32 id, struct process_info *pi) {
 }
 
 /* register a buffer */
-/* must have mutex */
 static s32 _m_register_buf(struct __buf_info *_b, struct process_info *pi)
 {
-        struct mem_info *mi = NULL;
+        struct mem_info *mi;
         struct tiler_buf_info *b = &_b->buf_info;
         u32 i, num = b->num_blocks, offs;
 
         /* check validity */
-        if (num > TILER_MAX_NUM_BLOCKS)
+        if (num > TILER_MAX_NUM_BLOCKS || num == 0)
                 return -EINVAL;
 
         /* find each block */
@@ -129,6 +131,11 @@ static s32 _m_register_buf(struct __buf_info *_b, struct process_info *pi)
                         return -EACCES;
                 }
                 _b->mi[i] = mi;
+
+                /* we don't keep track of ptr and 1D stride so clear them */
+                b->blocks[i].ptr = NULL;
+                b->blocks[i].stride = 0;
+
                 ops->describe(mi, b->blocks + i);
                 b->length += tiler_size(&mi->blk);
         }
@@ -138,13 +145,13 @@ static s32 _m_register_buf(struct __buf_info *_b, struct process_info *pi)
         b->offset = _m_get_offs(pi, b->length) + offs;
         b->length -= offs;
 
+        /* have mutex */
         list_add(&_b->by_pid, &pi->bufs);
 
         return 0;
 }
 
 /* unregister a buffer */
-/* must have mutex */
 static void _m_unregister_buf(struct __buf_info *_b)
 {
         u32 i;
@@ -164,15 +171,16 @@ static void _m_unregister_buf(struct __buf_info *_b)
  *  ==========================================================================
  */
 
-
 /* get process info, and increment refs for device tracking */
 static struct process_info *__get_pi(pid_t pid, bool kernel)
 {
         struct process_info *pi;
 
-        /* treat all processes as the same, kernel processes are still treated
-           differently so not to free kernel allocated areas when a user process
-           closes the tiler driver */
+        /*
+         * treat all processes as the same, kernel processes are still treated
+         * differently so not to free kernel allocated areas when a user process
+         * closes the tiler driver
+         */
         if (!security)
                 pid = 0;
 
@@ -187,14 +195,15 @@ static struct process_info *__get_pi(pid_t pid, bool kernel)
         pi = kmalloc(sizeof(*pi), GFP_KERNEL);
         if (!pi)
                 goto done;
-
         memset(pi, 0, sizeof(*pi));
+
         pi->pid = pid;
         pi->kernel = kernel;
         INIT_LIST_HEAD(&pi->groups);
         INIT_LIST_HEAD(&pi->bufs);
         list_add(&pi->list, &procs);
 done:
+        /* increment reference count */
         if (pi && !kernel)
                 pi->refs++;
         mutex_unlock(&mtx);
@@ -202,20 +211,17 @@ done:
 }
 
 /**
- * Free all info kept by a process:
- *
- * all registered buffers, allocated blocks, and unreferenced
- * blocks.  Any blocks/areas still referenced will move to the
- * orphaned lists to avoid issues if a new process is created
- * with the same pid.
- *
- * (must have mutex)
+ * Free all info kept by a process: all registered buffers, allocated blocks,
+ * and unreferenced blocks.  Any blocks/areas still referenced will move to the
+ * orphaned lists to avoid issues if a new process is created with the same pid.
  */
-void _m_free_process_info(struct process_info *pi)
+static void _m_free_process_info(struct process_info *pi)
 {
         struct gid_info *gi, *gi_;
         struct __buf_info *_b = NULL, *_b_ = NULL;
 
+        /* have mutex */
+
         /* unregister all buffers */
         list_for_each_entry_safe(_b, _b_, &pi->bufs, by_pid)
                 _m_unregister_buf(_b);
@@ -223,15 +229,15 @@ void _m_free_process_info(struct process_info *pi)
         BUG_ON(!list_empty(&pi->bufs));
 
         /* free all allocated blocks, and remove unreferenced ones */
-        list_for_each_entry_safe(gi, gi_, &pi->groups, by_pid) {
+        list_for_each_entry_safe(gi, gi_, &pi->groups, by_pid)
                 ops->destroy_group(gi);
-        }
 
         BUG_ON(!list_empty(&pi->groups));
         list_del(&pi->list);
         kfree(pi);
 }
 
+/* Free all info kept by all processes.  Called on cleanup. */
 static void destroy_processes(void)
 {
         struct process_info *pi, *pi_;
@@ -250,9 +256,10 @@ static void destroy_processes(void)
  *  ==========================================================================
  */
 
+/* mmap tiler buffer into user's virtual space */
 static s32 tiler_mmap(struct file *filp, struct vm_area_struct *vma)
 {
-        struct __buf_info *_b = NULL;
+        struct __buf_info *_b;
         struct tiler_buf_info *b = NULL;
         u32 i, map_offs, map_size, blk_offs, blk_size, mapped_size;
         struct process_info *pi = filp->private_data;
@@ -261,8 +268,10 @@ static s32 tiler_mmap(struct file *filp, struct vm_area_struct *vma)
 
         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 
+        /* find tiler buffer to mmap */
         mutex_lock(&mtx);
         list_for_each_entry(_b, &pi->bufs, by_pid) {
+                /* we support partial mmaping of a whole tiler buffer */
                 if (offs >= (_b->buf_info.offset & PAGE_MASK) &&
                     offs + size <= PAGE_ALIGN(_b->buf_info.offset +
                                                 _b->buf_info.length)) {
@@ -271,44 +280,55 @@ static s32 tiler_mmap(struct file *filp, struct vm_area_struct *vma)
                 }
         }
         mutex_unlock(&mtx);
+
+        /* we use b to detect if we found the bufffer */
         if (!b)
                 return -ENXIO;
 
         /* mmap relevant blocks */
         blk_offs = _b->buf_info.offset;
+
+        /* start at the beginning of the region */
         mapped_size = 0;
         for (i = 0; i < b->num_blocks; i++, blk_offs += blk_size) {
                 blk_size = tiler_size(&_b->mi[i]->blk);
+                /* see if tiler block is inside the requested region */
                 if (offs >= blk_offs + blk_size || offs + size < blk_offs)
                         continue;
+                /* get the offset and map size for this particular block */
                 map_offs = max(offs, blk_offs) - blk_offs;
                 map_size = min(size - mapped_size, blk_size);
+
+                /* mmap block */
                 if (tiler_mmap_blk(&_b->mi[i]->blk, map_offs, map_size, vma,
                                    mapped_size))
                         return -EAGAIN;
+
+                /* update mmap region pointer */
                 mapped_size += map_size;
         }
         return 0;
 }
 
+/* ioctl handler */
 static s32 tiler_ioctl(struct inode *ip, struct file *filp, u32 cmd,
                         unsigned long arg)
 {
-        pgd_t *pgd = NULL;
-        pmd_t *pmd = NULL;
-        pte_t *ptep = NULL, pte = 0x0;
-        s32 r = -1;
+        pgd_t *pgd;
+        pmd_t *pmd;
+        pte_t *ptep, pte;
+        s32 r;
+        void __user *data = (void __user *)arg;
         struct process_info *pi = filp->private_data;
-
-        struct __buf_info *_b = NULL;
+        struct __buf_info *_b;
         struct tiler_buf_info buf_info = {0};
         struct tiler_block_info block_info = {0};
-        struct mem_info *mi = NULL;
+        struct mem_info *mi;
 
         switch (cmd) {
+        /* allocate block */
         case TILIOC_GBLK:
-                if (copy_from_user(&block_info, (void __user *)arg,
-                                        sizeof(block_info)))
+                if (copy_from_user(&block_info, data, sizeof(block_info)))
                         return -EFAULT;
 
                 switch (block_info.fmt) {
@@ -317,8 +337,6 @@ static s32 tiler_ioctl(struct inode *ip, struct file *filp, u32 cmd,
                                         block_info.align, block_info.offs,
                                         block_info.key, block_info.group_id,
                                         pi, &mi);
-                        if (r)
-                                return r;
                         break;
                 case TILFMT_8BIT:
                 case TILFMT_16BIT:
@@ -329,45 +347,38 @@ static s32 tiler_ioctl(struct inode *ip, struct file *filp, u32 cmd,
                                         block_info.align, block_info.offs,
                                         block_info.key, block_info.group_id,
                                         pi, &mi);
-                        if (r)
-                                return r;
                         break;
                 default:
                         return -EINVAL;
                 }
+                if (r)
+                        return r;
 
+                /* fill out block info */
                 if (mi) {
-                        block_info.id = mi->blk.id;
-                        block_info.stride = tiler_vstride(&mi->blk);
-                        block_info.offs = mi->blk.phys & ~PAGE_MASK;
-                        block_info.align = PAGE_SIZE;
-#ifdef CONFIG_TILER_EXPOSE_SSPTR
-                        block_info.ssptr = mi->blk.phys;
-#endif
+                        block_info.ptr = NULL;
+                        ops->describe(mi, &block_info);
                 }
-                if (copy_to_user((void __user *)arg, &block_info,
-                                        sizeof(block_info)))
+
+                if (copy_to_user(data, &block_info, sizeof(block_info)))
                         return -EFAULT;
                 break;
+        /* free/unmap block */
         case TILIOC_FBLK:
         case TILIOC_UMBLK:
-                if (copy_from_user(&block_info, (void __user *)arg,
-                                        sizeof(block_info)))
+                if (copy_from_user(&block_info, data, sizeof(block_info)))
                         return -EFAULT;
 
                 /* search current process first, then all processes */
                 mutex_lock(&mtx);
                 mi = _m_lock_block(block_info.key, block_info.id, pi);
                 mutex_unlock(&mtx);
-                if (mi) {
+                if (mi)
                         ops->unlock_free(mi, true);
-                        r = 0;
-                }
-                r = -EACCES;
 
                 /* free always succeeds */
                 break;
-
+        /* get physical address */
         case TILIOC_GSSP:
                 pgd = pgd_offset(current->mm, arg);
                 if (!(pgd_none(*pgd) || pgd_bad(*pgd))) {
@@ -382,12 +393,12 @@ static s32 tiler_ioctl(struct inode *ip, struct file *filp, u32 cmd,
                                 }
                         }
                 }
-                /* va not in page table */
-                return 0x0;
+                /* va not in page table, return NULL */
+                return (s32) NULL;
                 break;
+        /* map block */
         case TILIOC_MBLK:
-                if (copy_from_user(&block_info, (void __user *)arg,
-                                        sizeof(block_info)))
+                if (copy_from_user(&block_info, data, sizeof(block_info)))
                         return -EFAULT;
 
                 if (!block_info.ptr)
@@ -399,30 +410,26 @@ static s32 tiler_ioctl(struct inode *ip, struct file *filp, u32 cmd,
                 if (r)
                         return r;
 
-                if (mi) {
-                        block_info.id = mi->blk.id;
-                        block_info.stride = tiler_vstride(&mi->blk);
-                        block_info.offs = mi->blk.phys & ~PAGE_MASK;
-                        block_info.align = PAGE_SIZE;
-#ifdef CONFIG_TILER_EXPOSE_SSPTR
-                        block_info.ssptr = mi->blk.phys;
-#endif
-                }
-                if (copy_to_user((void __user *)arg, &block_info,
-                                        sizeof(block_info)))
+                /* fill out block info */
+                if (mi)
+                        ops->describe(mi, &block_info);
+
+                if (copy_to_user(data, &block_info, sizeof(block_info)))
                         return -EFAULT;
                 break;
 #ifndef CONFIG_TILER_SECURE
+        /* query buffer information by offset */
         case TILIOC_QBUF:
                 if (!offset_lookup)
                         return -EPERM;
 
-                if (copy_from_user(&buf_info, (void __user *)arg,
-                                        sizeof(buf_info)))
+                if (copy_from_user(&buf_info, data, sizeof(buf_info)))
                         return -EFAULT;
 
+                /* find buffer */
                 mutex_lock(&mtx);
                 r = -ENOENT;
+                /* buffer registration is per process */
                 list_for_each_entry(_b, &pi->bufs, by_pid) {
                         if (buf_info.offset == _b->buf_info.offset) {
                                 memcpy(&buf_info, &_b->buf_info,
@@ -436,21 +443,21 @@ static s32 tiler_ioctl(struct inode *ip, struct file *filp, u32 cmd,
                 if (r)
                         return r;
 
-                if (copy_to_user((void __user *)arg, &_b->buf_info,
-                                                sizeof(_b->buf_info)))
+                if (copy_to_user(data, &_b->buf_info, sizeof(_b->buf_info)))
                         return -EFAULT;
                 break;
 #endif
+        /* register buffer */
         case TILIOC_RBUF:
+                /* save buffer information */
                 _b = kmalloc(sizeof(*_b), GFP_KERNEL);
                 if (!_b)
                         return -ENOMEM;
+                memset(_b, 0, sizeof(*_b));
 
-                memset(_b, 0x0, sizeof(*_b));
-
-                if (copy_from_user(&_b->buf_info, (void __user *)arg,
-                                        sizeof(_b->buf_info))) {
-                        kfree(_b); return -EFAULT;
+                if (copy_from_user(&_b->buf_info, data, sizeof(_b->buf_info))) {
+                        kfree(_b);
+                        return -EFAULT;
                 }
 
                 mutex_lock(&mtx);
@@ -458,28 +465,31 @@ static s32 tiler_ioctl(struct inode *ip, struct file *filp, u32 cmd,
                 mutex_unlock(&mtx);
 
                 if (r) {
-                        kfree(_b); return -EACCES;
+                        kfree(_b);
+                        return -EACCES;
                 }
 
-                if (copy_to_user((void __user *)arg, &_b->buf_info,
-                                        sizeof(_b->buf_info))) {
+                /* undu registration on failure */
+                if (copy_to_user(data, &_b->buf_info, sizeof(_b->buf_info))) {
                         mutex_lock(&mtx);
                         _m_unregister_buf(_b);
                         mutex_unlock(&mtx);
                         return -EFAULT;
                 }
                 break;
+        /* unregister a buffer */
         case TILIOC_URBUF:
-                if (copy_from_user(&buf_info, (void __user *)arg,
-                                        sizeof(buf_info)))
+                if (copy_from_user(&buf_info, data, sizeof(buf_info)))
                         return -EFAULT;
 
+                /* find buffer */
                 r = -EFAULT;
                 mutex_lock(&mtx);
                 /* buffer registration is per process */
                 list_for_each_entry(_b, &pi->bufs, by_pid) {
                         if (buf_info.offset == _b->buf_info.offset) {
                                 _m_unregister_buf(_b);
+                                /* only retrieve buffer length */
                                 buf_info.length = _b->buf_info.length;
                                 r = 0;
                                 break;
@@ -487,25 +497,25 @@ static s32 tiler_ioctl(struct inode *ip, struct file *filp, u32 cmd,
                 }
                 mutex_unlock(&mtx);
 
-                if (copy_to_user((void __user *)arg, &buf_info,
-                                        sizeof(_b->buf_info)))
-                        return -EFAULT;
+                if (r)
+                        return r;
 
-                return r;
+                if (copy_to_user(data, &buf_info, sizeof(_b->buf_info)))
+                        return -EFAULT;
                 break;
+        /* prereserv blocks */
         case TILIOC_PRBLK:
-                if (copy_from_user(&block_info, (void __user *)arg,
-                                        sizeof(block_info)))
+                if (copy_from_user(&block_info, data, sizeof(block_info)))
                         return -EFAULT;
 
-                if (block_info.fmt == TILFMT_8AND16) {
+                if (block_info.fmt == TILFMT_8AND16)
                         ops->reserve_nv12(block_info.key,
                                           block_info.dim.area.width,
                                           block_info.dim.area.height,
                                           block_info.align,
                                           block_info.offs,
                                           block_info.group_id, pi);
-                } else {
+                else
                         ops->reserve(block_info.key,
                                      block_info.fmt,
                                      block_info.dim.area.width,
@@ -513,14 +523,14 @@ static s32 tiler_ioctl(struct inode *ip, struct file *filp, u32 cmd,
                                      block_info.align,
                                      block_info.offs,
                                      block_info.group_id, pi);
-                }
                 break;
+        /* unreserve blocks */
         case TILIOC_URBLK:
                 ops->unreserve(arg, pi);
                 break;
+        /* query a tiler block */
         case TILIOC_QBLK:
-                if (copy_from_user(&block_info, (void __user *)arg,
-                                        sizeof(block_info)))
+                if (copy_from_user(&block_info, data, sizeof(block_info)))
                         return -EFAULT;
 
                 if (block_info.id) {
@@ -537,24 +547,26 @@ static s32 tiler_ioctl(struct inode *ip, struct file *filp, u32 cmd,
 #endif
                         return -EPERM;
 
-                if (mi) {
-                        ops->describe(mi, &block_info);
-                        ops->unlock_free(mi, false);
-                }
-
                 if (!mi)
                         return -EFAULT;
 
-                if (copy_to_user((void __user *)arg, &block_info,
-                        sizeof(block_info)))
+                /* we don't keep track of ptr and 1D stride so clear them */
+                block_info.ptr = NULL;
+                block_info.stride = 0;
+
+                ops->describe(mi, &block_info);
+                ops->unlock_free(mi, false);
+
+                if (copy_to_user(data, &block_info, sizeof(block_info)))
                         return -EFAULT;
                 break;
         default:
                 return -EINVAL;
         }
-        return 0x0;
+        return 0;
 }
 
+/* open tiler driver */
 static s32 tiler_open(struct inode *ip, struct file *filp)
 {
         struct process_info *pi = __get_pi(current->tgid, false);
@@ -562,9 +574,10 @@ static s32 tiler_open(struct inode *ip, struct file *filp)
                 return -ENOMEM;
 
         filp->private_data = pi;
-        return 0x0;
+        return 0;
 }
 
+/* close tiler driver */
 static s32 tiler_release(struct inode *ip, struct file *filp)
 {
         struct process_info *pi = filp->private_data;
@@ -576,16 +589,18 @@ static s32 tiler_release(struct inode *ip, struct file *filp)
 
         mutex_unlock(&mtx);
 
-        return 0x0;
+        return 0;
 }
 
-const struct file_operations tiler_fops = {
+/* tiler driver file operations */
+static const struct file_operations tiler_fops = {
         .open    = tiler_open,
         .ioctl   = tiler_ioctl,
         .release = tiler_release,
         .mmap    = tiler_mmap,
 };
 
+/* initialize tiler interface */
 void tiler_iface_init(struct tiler_ops *tiler)
 {
         ops = tiler;
@@ -606,41 +621,36 @@ void tiler_iface_init(struct tiler_ops *tiler)
  *  ==========================================================================
  */
 
-s32 tiler_reservex(u32 n, enum tiler_fmt fmt, u32 width, u32 height,
+void tiler_reservex(u32 n, enum tiler_fmt fmt, u32 width, u32 height,
                    u32 align, u32 offs, u32 gid, pid_t pid)
 {
         struct process_info *pi = __get_pi(pid, true);
 
         if (pi)
                 ops->reserve(n, fmt, width, height, align, offs, gid, pi);
-        return 0;
 }
 EXPORT_SYMBOL(tiler_reservex);
 
-s32 tiler_reserve(u32 n, enum tiler_fmt fmt, u32 width, u32 height,
+void tiler_reserve(u32 n, enum tiler_fmt fmt, u32 width, u32 height,
                   u32 align, u32 offs)
 {
-        return tiler_reservex(n, fmt, width, height, align, offs,
-                              0, current->tgid);
+        tiler_reservex(n, fmt, width, height, align, offs, 0, current->tgid);
 }
 EXPORT_SYMBOL(tiler_reserve);
 
-/* reserve area for n identical buffers */
-s32 tiler_reservex_nv12(u32 n, u32 width, u32 height, u32 align, u32 offs,
+void tiler_reservex_nv12(u32 n, u32 width, u32 height, u32 align, u32 offs,
                         u32 gid, pid_t pid)
 {
         struct process_info *pi = __get_pi(pid, true);
 
         if (pi)
                 ops->reserve_nv12(n, width, height, align, offs, gid, pi);
-        return 0;
 }
 EXPORT_SYMBOL(tiler_reservex_nv12);
 
-s32 tiler_reserve_nv12(u32 n, u32 width, u32 height, u32 align, u32 offs)
+void tiler_reserve_nv12(u32 n, u32 width, u32 height, u32 align, u32 offs)
 {
-        return tiler_reservex_nv12(n, width, height, align, offs,
-                                   0, current->tgid);
+        tiler_reservex_nv12(n, width, height, align, offs, 0, current->tgid);
 }
 EXPORT_SYMBOL(tiler_reserve_nv12);
 
@@ -651,8 +661,7 @@ s32 tiler_allocx(struct tiler_block_t *blk, enum tiler_fmt fmt,
         struct process_info *pi;
         s32 res;
 
-        if (!blk || blk->phys)
-                BUG();
+        BUG_ON(!blk || blk->phys);
 
         pi = __get_pi(pid, true);
         if (!pi)
@@ -682,8 +691,7 @@ s32 tiler_mapx(struct tiler_block_t *blk, enum tiler_fmt fmt, u32 gid,
         struct process_info *pi;
         s32 res;
 
-        if (!blk || blk->phys)
-                BUG();
+        BUG_ON(!blk || blk->phys);
 
         pi = __get_pi(pid, true);
         if (!pi)
@@ -709,22 +717,18 @@ EXPORT_SYMBOL(tiler_map);
 s32 tiler_mmap_blk(struct tiler_block_t *blk, u32 offs, u32 size,
                                 struct vm_area_struct *vma, u32 voffs)
 {
-        u32 v, p;
-        u32 len;        /* area to map */
+        u32 v, p, len;
 
         /* don't allow mremap */
         vma->vm_flags |= VM_DONTEXPAND | VM_RESERVED;
 
         /* mapping must fit into vma */
-        if (vma->vm_start > vma->vm_start + voffs ||
-            vma->vm_start + voffs > vma->vm_start + voffs + size ||
-            vma->vm_start + voffs + size > vma->vm_end)
-                BUG();
+        BUG_ON(vma->vm_start > vma->vm_start + voffs ||
+                vma->vm_start + voffs > vma->vm_start + voffs + size ||
+                vma->vm_start + voffs + size > vma->vm_end);
 
         /* mapping must fit into block */
-        if (offs > offs + size ||
-            offs + size > tiler_size(blk))
-                BUG();
+        BUG_ON(offs > offs + size || offs + size > tiler_size(blk));
 
         v = tiler_vstride(blk);
         p = tiler_pstride(blk);
@@ -732,6 +736,7 @@ s32 tiler_mmap_blk(struct tiler_block_t *blk, u32 offs, u32 size,
         /* remap block portion */
         len = v - (offs % v);   /* initial area to map */
         while (size) {
+                /* restrict to size still needs mapping */
                 if (len > size)
                         len = size;
 
@@ -756,13 +761,10 @@ s32 tiler_ioremap_blk(struct tiler_block_t *blk, u32 offs, u32 size,
         const struct mem_type *type = get_mem_type(mtype);
 
         /* mapping must fit into address space */
-        if (addr > addr + size)
-                BUG();
+        BUG_ON(addr > addr + size);
 
         /* mapping must fit into block */
-        if (offs > offs + size ||
-            offs + size > tiler_size(blk))
-                BUG();
+        BUG_ON(offs > offs + size || offs + size > tiler_size(blk));
 
         v = tiler_vstride(blk);
         p = tiler_pstride(blk);
diff --git a/drivers/media/video/tiler/tiler-main.c b/drivers/media/video/tiler/tiler-main.c
index c755567edd5..19e838f9ec3 100644
--- a/drivers/media/video/tiler/tiler-main.c
+++ b/drivers/media/video/tiler/tiler-main.c
@@ -1,7 +1,10 @@
 /*
  * tiler-main.c
  *
- * TILER driver support functions for TI OMAP processors.
+ * TILER driver main support functions for TI TILER hardware block.
+ *
+ * Authors: Lajos Molnar <molnar@ti.com>
+ *          David Sin <davidsin@ti.com>
  *
  * Copyright (C) 2009-2010 Texas Instruments, Inc.
  *
@@ -16,39 +19,39 @@
 
 #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/sched.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/errno.h>
 #include <linux/mutex.h>
-#include <linux/dma-mapping.h>
-#include <linux/pagemap.h>         /* page_cache_release() */
+#include <linux/dma-mapping.h>          /* dma_alloc_coherent */
+#include <linux/pagemap.h>              /* page_cache_release() */
 #include <linux/slab.h>
 
 #include <mach/dmm.h>
 #include "tmm.h"
 #include "_tiler.h"
-#include "tcm/tcm-sita.h"       /* Algo Specific header */
-
-#include <linux/syscalls.h>
+#include "tcm/tcm-sita.h"               /* TCM algorithm */
 
 static bool ssptr_id = CONFIG_TILER_SSPTR_ID;
 static uint default_align = CONFIG_TILER_ALIGNMENT;
 static uint granularity = CONFIG_TILER_GRANULARITY;
 
-module_param(ssptr_id, bool, 0644);
+/*
+ * We can only change ssptr_id if there are no blocks allocated, so that
+ * pseudo-random ids and ssptrs do not potentially clash. For now make it
+ * read-only.
+ */
+module_param(ssptr_id, bool, 0444);
 MODULE_PARM_DESC(ssptr_id, "Use ssptr as block ID");
 module_param_named(align, default_align, uint, 0644);
 MODULE_PARM_DESC(align, "Default block ssptr alignment");
 module_param_named(grain, granularity, uint, 0644);
 MODULE_PARM_DESC(grain, "Granularity (bytes)");
 
-struct tiler_ops tiler;
-
 struct tiler_dev {
         struct cdev cdev;
 };
@@ -63,9 +66,11 @@ struct platform_driver tiler_driver_ldm = {
         .remove = NULL,
 };
 
-static struct list_head blocks;
-static struct list_head orphan_areas;
-static struct list_head orphan_onedim;
+static struct tiler_ops tiler;          /* shared methods and variables */
+
+static struct list_head blocks;         /* all tiler blocks */
+static struct list_head orphan_areas;   /* orphaned 2D areas */
+static struct list_head orphan_onedim;  /* orphaned 1D areas */
 
 static s32 tiler_major;
 static s32 tiler_minor;
@@ -81,6 +86,7 @@ static dma_addr_t dmac_pa;
  *  TMM connectors
  *  ==========================================================================
  */
+/* wrapper around tmm_map */
 static s32 refill_pat(struct tmm *tmm, struct tcm_area *area, u32 *ptr)
 {
         s32 res = 0;
@@ -105,6 +111,7 @@ static s32 refill_pat(struct tmm *tmm, struct tcm_area *area, u32 *ptr)
         return res;
 }
 
+/* wrapper around tmm_clear */
 static void clear_pat(struct tmm *tmm, struct tcm_area *area)
 {
         struct pat_area p_area = {0};
@@ -142,6 +149,8 @@ static u32 _m_get_id(void)
 
         /* ensure noone is using this id */
         while (_m_id_in_use(id)) {
+                /* generate a new pseudo-random ID */
+
                 /* Galois LSFR: 32, 22, 2, 1 */
                 id = (id >> 1) ^ (u32)((0 - (id & 1u)) & 0x80200003u);
         }
@@ -154,11 +163,13 @@ static u32 _m_get_id(void)
  *  ==========================================================================
  */
 
-/* must have mutex */
+/* get or create new gid_info object */
 static struct gid_info *_m_get_gi(struct process_info *pi, u32 gid)
 {
         struct gid_info *gi;
 
+        /* have mutex */
+
         /* see if group already exist */
         list_for_each_entry(gi, &pi->groups, by_pid) {
                 if (gi->gid == gid)
@@ -186,9 +197,10 @@ done:
         return gi;
 }
 
-/* (must have mutex) */
+/* free gid_info object if empty */
 static void _m_try_free_group(struct gid_info *gi)
 {
+        /* have mutex */
         if (gi && list_empty(&gi->areas) && list_empty(&gi->onedim) &&
             /* also ensure noone is still using this group */
             !gi->refs) {
@@ -277,11 +289,11 @@ static s32 __analize_area(enum tiler_fmt fmt, u32 width, u32 height,
 
         /* width and height must be positive */
         if (!width || !height)
-                return -1;
+                return -EINVAL;
 
         /* align must be 2 power */
         if (*align & (*align - 1))
-                return -1;
+                return -EINVAL;
 
         if (fmt == TILFMT_PAGE) {
                 /* adjust size to accomodate offset, only do page alignment */
@@ -294,7 +306,7 @@ static s32 __analize_area(enum tiler_fmt fmt, u32 width, u32 height,
                 *y_area = *band = 1;
 
                 if (*x_area * *y_area > tiler.width * tiler.height)
-                        return -1;
+                        return -ENOMEM;
                 return 0;
         }
 
@@ -310,9 +322,13 @@ static s32 __analize_area(enum tiler_fmt fmt, u32 width, u32 height,
         *band = PAGE_SIZE / slot_row;
 
         /* minimum alignment is at least 1 slot.  Use default if needed */
-        min_align = MAX(slot_row, granularity);
+        min_align = max(slot_row, granularity);
         *align = ALIGN(*align ? : default_align, min_align);
 
+        /* align must still be 2 power (in case default_align is wrong) */
+        if (*align & (*align - 1))
+                return -EAGAIN;
+
         /* offset must be multiple of bpp */
         if (*offs & (g->bpp - 1) || *offs >= *align)
                 return -EINVAL;
@@ -334,8 +350,8 @@ static s32 __analize_area(enum tiler_fmt fmt, u32 width, u32 height,
         *offs /= slot_row;
 
         if (*x_area > tiler.width || *y_area > tiler.height)
-                return -1;
-        return 0x0;
+                return -ENOMEM;
+        return 0;
 }
 
 /**
@@ -811,13 +827,12 @@ found:
 /* find a block by ssptr */
 static void fill_block_info(struct mem_info *i, struct tiler_block_info *blk)
 {
-        blk->ptr = NULL;
         blk->fmt = tiler_fmt(i->blk.phys);
+#ifdef CONFIG_TILER_EXPOSE_SSPTR
         blk->ssptr = i->blk.phys;
-
+#endif
         if (blk->fmt == TILFMT_PAGE) {
                 blk->dim.len = i->blk.width;
-                blk->stride = 0;
                 blk->group_id = ((struct gid_info *) i->parent)->gid;
         } else {
                 blk->stride = tiler_vstride(&i->blk);
@@ -1248,7 +1263,7 @@ static void __exit tiler_exit(void)
 }
 
 MODULE_LICENSE("GPL v2");
-MODULE_AUTHOR("David Sin <davidsin@ti.com>");
 MODULE_AUTHOR("Lajos Molnar <molnar@ti.com>");
+MODULE_AUTHOR("David Sin <davidsin@ti.com>");
 module_init(tiler_init);
 module_exit(tiler_exit);
diff --git a/drivers/media/video/tiler/tmm-pat.c b/drivers/media/video/tiler/tmm-pat.c
index bfef67cbe39..d33866b125e 100644
--- a/drivers/media/video/tiler/tmm-pat.c
+++ b/drivers/media/video/tiler/tmm-pat.c
@@ -1,7 +1,7 @@
 /*
  * tmm-pat.c
  *
- * DMM driver support functions for TI OMAP processors.
+ * DMM driver support functions for TI TILER hardware block.
  *
  * Author: Lajos Molnar <molnar@ti.com>, David Sin <dsin@ti.com>
  *
diff --git a/drivers/media/video/tiler/tmm.h b/drivers/media/video/tiler/tmm.h
index 31470b3e44d..fbdc1e23d0e 100644
--- a/drivers/media/video/tiler/tmm.h
+++ b/drivers/media/video/tiler/tmm.h
@@ -1,7 +1,7 @@
 /*
  * tmm.h
  *
- * TMM interface definition for TI TILER.
+ * TMM interface definition for TI TILER driver.
  *
  * Author: Lajos Molnar <molnar@ti.com>
  *