diff --git a/arch/arm/mach-tegra/include/mach/dc.h b/arch/arm/mach-tegra/include/mach/dc.h
index ce562e5634f7..49c09a177d00 100644
--- a/arch/arm/mach-tegra/include/mach/dc.h
+++ b/arch/arm/mach-tegra/include/mach/dc.h
@@ -86,6 +86,7 @@ struct tegra_dc_out {
 #define TEGRA_DC_ORDER_BLUE_RED		1
 
 struct tegra_dc;
+struct nvmap_handle_ref;
 
 struct tegra_dc_win {
 	u8			idx;
@@ -108,6 +109,8 @@ struct tegra_dc_win {
 
 	int			dirty;
 	struct tegra_dc		*dc;
+
+	struct nvmap_handle_ref	*surface;
 };
 
 #define TEGRA_WIN_FLAG_ENABLED		(1 << 0)
@@ -165,6 +168,10 @@ struct tegra_dc_win *tegra_dc_get_window(struct tegra_dc *dc, unsigned win);
 void tegra_dc_enable(struct tegra_dc *dc);
 void tegra_dc_disable(struct tegra_dc *dc);
 
+u32 tegra_dc_get_syncpt_id(const struct tegra_dc *dc);
+u32 tegra_dc_incr_syncpt_max(struct tegra_dc *dc);
+void tegra_dc_incr_syncpt_min(struct tegra_dc *dc, u32 val);
+
 /* tegra_dc_update_windows and tegra_dc_sync_windows do not support windows
  * with differenct dcs in one call
  */
diff --git a/drivers/video/tegra/dc/dc.c b/drivers/video/tegra/dc/dc.c
index fadecf4796e1..16e6a454336d 100644
--- a/drivers/video/tegra/dc/dc.c
+++ b/drivers/video/tegra/dc/dc.c
@@ -102,6 +102,8 @@ static void _dump_regs(struct tegra_dc *dc, void *data,
 	int i;
 	char buff[256];
 
+	tegra_dc_io_start(dc);
+
 	DUMP_REG(DC_CMD_DISPLAY_COMMAND_OPTION0);
 	DUMP_REG(DC_CMD_DISPLAY_COMMAND);
 	DUMP_REG(DC_CMD_SIGNAL_RAISE);
@@ -225,6 +227,8 @@ static void _dump_regs(struct tegra_dc *dc, void *data,
 		DUMP_REG(DC_WINBUF_ADDR_H_OFFSET);
 		DUMP_REG(DC_WINBUF_ADDR_V_OFFSET);
 	}
+
+	tegra_dc_io_end(dc);
 }
 
 #undef DUMP_REG
@@ -285,7 +289,6 @@ static void tegra_dc_dbg_add(struct tegra_dc *dc)
 
 	snprintf(name, sizeof(name), "tegra_dc%d_regs", dc->ndev->id);
 	(void) debugfs_create_file(name, S_IRUGO, NULL, dc, &dbg_fops);
-
 }
 #else
 static void tegra_dc_dbg_add(struct tegra_dc *dc) {}
@@ -533,13 +536,40 @@ int tegra_dc_update_windows(struct tegra_dc_win *windows[], int n)
 	}
 
 	tegra_dc_writel(dc, update_mask, DC_CMD_STATE_CONTROL);
-
 	mutex_unlock(&dc->lock);
 
 	return 0;
 }
 EXPORT_SYMBOL(tegra_dc_update_windows);
 
+u32 tegra_dc_get_syncpt_id(const struct tegra_dc *dc)
+{
+	return dc->syncpt_id;
+}
+EXPORT_SYMBOL(tegra_dc_get_syncpt_id);
+
+u32 tegra_dc_incr_syncpt_max(struct tegra_dc *dc)
+{
+	u32 max;
+
+	mutex_lock(&dc->lock);
+	max = nvhost_syncpt_incr_max(&dc->ndev->host->syncpt, dc->syncpt_id, 1);
+	dc->syncpt_max = max;
+	mutex_unlock(&dc->lock);
+
+	return max;
+}
+
+void tegra_dc_incr_syncpt_min(struct tegra_dc *dc, u32 val)
+{
+	mutex_lock(&dc->lock);
+	while (dc->syncpt_min < val) {
+		dc->syncpt_min++;
+		nvhost_syncpt_cpu_incr(&dc->ndev->host->syncpt, dc->syncpt_id);
+	}
+	mutex_unlock(&dc->lock);
+}
+
 static bool tegra_dc_windows_are_clean(struct tegra_dc_win *windows[],
 					     int n)
 {
@@ -769,11 +799,18 @@ static void tegra_dc_set_color_control(struct tegra_dc *dc)
 
 static void tegra_dc_init(struct tegra_dc *dc)
 {
+	u32 disp_syncpt;
+	u32 vblank_syncpt;
+
 	tegra_dc_writel(dc, 0x00000100, DC_CMD_GENERAL_INCR_SYNCPT_CNTRL);
-	if (dc->ndev->id == 0)
-		tegra_dc_writel(dc, 0x0000011a, DC_CMD_CONT_SYNCPT_VSYNC);
-	else
-		tegra_dc_writel(dc, 0x0000011b, DC_CMD_CONT_SYNCPT_VSYNC);
+	if (dc->ndev->id == 0) {
+		disp_syncpt = NVSYNCPT_DISP0;
+		vblank_syncpt = NVSYNCPT_VBLANK0;
+	} else if (dc->ndev->id == 1) {
+		disp_syncpt = NVSYNCPT_DISP1;
+		vblank_syncpt = NVSYNCPT_VBLANK1;
+	}
+	tegra_dc_writel(dc, 0x00000100 | vblank_syncpt, DC_CMD_CONT_SYNCPT_VSYNC);
 	tegra_dc_writel(dc, 0x00004700, DC_CMD_INT_TYPE);
 	tegra_dc_writel(dc, 0x0001c700, DC_CMD_INT_POLARITY);
 	tegra_dc_writel(dc, 0x00000020, DC_DISP_MEM_HIGH_PRIORITY);
@@ -786,18 +823,24 @@ static void tegra_dc_init(struct tegra_dc *dc)
 
 	tegra_dc_set_color_control(dc);
 
+	dc->syncpt_id = disp_syncpt;
+
+	dc->syncpt_min = dc->syncpt_max =
+		nvhost_syncpt_read(&dc->ndev->host->syncpt, disp_syncpt);
+
 	if (dc->mode.pclk)
 		tegra_dc_program_mode(dc, &dc->mode);
 }
 
 static void _tegra_dc_enable(struct tegra_dc *dc)
 {
+	tegra_dc_io_start(dc);
+
 	if (dc->out && dc->out->enable)
 		dc->out->enable();
 
 	tegra_dc_setup_clk(dc, dc->clk);
 
-	clk_enable(dc->host1x_clk);
 	clk_enable(dc->clk);
 	tegra_periph_reset_deassert(dc->clk);
 	enable_irq(dc->irq);
@@ -831,10 +874,17 @@ static void _tegra_dc_disable(struct tegra_dc *dc)
 	disable_irq(dc->irq);
 	tegra_periph_reset_assert(dc->clk);
 	clk_disable(dc->clk);
-	clk_disable(dc->host1x_clk);
 
 	if (dc->out && dc->out->disable)
 		dc->out->disable();
+
+	/* flush any pending syncpt waits */
+	while (dc->syncpt_min < dc->syncpt_max) {
+		dc->syncpt_min++;
+		nvhost_syncpt_cpu_incr(&dc->ndev->host->syncpt, dc->syncpt_id);
+	}
+
+	tegra_dc_io_end(dc);
 }
 
 
@@ -854,7 +904,6 @@ static int tegra_dc_probe(struct nvhost_device *ndev)
 {
 	struct tegra_dc *dc;
 	struct clk *clk;
-	struct clk *host1x_clk;
 	struct resource	*res;
 	struct resource *base_res;
 	struct resource *fb_mem = NULL;
@@ -904,23 +953,14 @@ static int tegra_dc_probe(struct nvhost_device *ndev)
 
 	fb_mem = nvhost_get_resource_byname(ndev, IORESOURCE_MEM, "fbmem");
 
-	host1x_clk = clk_get(&ndev->dev, "host1x");
-	if (IS_ERR_OR_NULL(host1x_clk)) {
-		dev_err(&ndev->dev, "can't get host1x clock\n");
-		ret = -ENOENT;
-		goto err_iounmap_reg;
-	}
-
 	clk = clk_get(&ndev->dev, NULL);
 	if (IS_ERR_OR_NULL(clk)) {
 		dev_err(&ndev->dev, "can't get clock\n");
 		ret = -ENOENT;
-
-		goto err_put_host1x_clk;
+		goto err_iounmap_reg;
 	}
 
 	dc->clk = clk;
-	dc->host1x_clk = host1x_clk;
 	dc->base_res = base_res;
 	dc->base = base;
 	dc->irq = irq;
@@ -984,8 +1024,6 @@ static int tegra_dc_probe(struct nvhost_device *ndev)
 	free_irq(irq, dc);
 err_put_clk:
 	clk_put(clk);
-err_put_host1x_clk:
-	clk_put(host1x_clk);
 err_iounmap_reg:
 	iounmap(base);
 	if (fb_mem)
@@ -1014,7 +1052,6 @@ static int tegra_dc_remove(struct nvhost_device *ndev)
 
 	free_irq(dc->irq, dc);
 	clk_put(dc->clk);
-	clk_put(dc->host1x_clk);
 	iounmap(dc->base);
 	if (dc->fb_mem)
 		release_resource(dc->base_res);
diff --git a/drivers/video/tegra/dc/dc_priv.h b/drivers/video/tegra/dc/dc_priv.h
index 2297be40f030..39a03e8fb9c0 100644
--- a/drivers/video/tegra/dc/dc_priv.h
+++ b/drivers/video/tegra/dc/dc_priv.h
@@ -22,6 +22,7 @@
 #include <linux/list.h>
 #include <linux/mutex.h>
 #include <linux/wait.h>
+#include "../host/dev.h"
 
 struct tegra_dc;
 
@@ -54,7 +55,6 @@ struct tegra_dc {
 	int				irq;
 
 	struct clk			*clk;
-	struct clk			*host1x_clk;
 
 	bool				enabled;
 
@@ -74,17 +74,33 @@ struct tegra_dc {
 
 	struct resource			*fb_mem;
 	struct tegra_fb_info		*fb;
+
+	u32				syncpt_id;
+	u32				syncpt_min;
+	u32				syncpt_max;
 };
 
+static inline void tegra_dc_io_start(struct tegra_dc *dc)
+{
+	nvhost_module_busy(&dc->ndev->host->mod);
+}
+
+static inline void tegra_dc_io_end(struct tegra_dc *dc)
+{
+	nvhost_module_idle(&dc->ndev->host->mod);
+}
+
 static inline unsigned long tegra_dc_readl(struct tegra_dc *dc,
 					   unsigned long reg)
 {
+	BUG_ON(!nvhost_module_powered(&dc->ndev->host->mod));
 	return readl(dc->base + reg * 4);
 }
 
 static inline void tegra_dc_writel(struct tegra_dc *dc, unsigned long val,
 				   unsigned long reg)
 {
+	BUG_ON(!nvhost_module_powered(&dc->ndev->host->mod));
 	writel(val, dc->base + reg * 4);
 }
 
diff --git a/drivers/video/tegra/fb.c b/drivers/video/tegra/fb.c
index 7e4ffa8ba0b9..1656a6e49279 100644
--- a/drivers/video/tegra/fb.c
+++ b/drivers/video/tegra/fb.c
@@ -23,13 +23,22 @@
 #include <linux/errno.h>
 #include <linux/string.h>
 #include <linux/mm.h>
+#include <linux/uaccess.h>
 #include <linux/slab.h>
+#include <linux/file.h>
+#include <linux/workqueue.h>
 
 #include <asm/atomic.h>
 
+#include <video/tegrafb.h>
+
 #include <mach/dc.h>
 #include <mach/fb.h>
 #include <mach/nvhost.h>
+#include <mach/nvmap.h>
+
+#include "host/dev.h"
+#include "nvmap/nvmap.h"
 
 struct tegra_fb_info {
 	struct tegra_dc_win	*win;
@@ -43,6 +52,24 @@ struct tegra_fb_info {
 	int			yres;
 
 	atomic_t		in_use;
+	struct nvmap_client	*user_nvmap;
+	struct nvmap_client	*fb_nvmap;
+
+	struct workqueue_struct	*flip_wq;
+};
+
+struct tegra_fb_flip_win {
+	struct tegra_dc_win	win_data;
+	struct tegra_dc_win	*dc_win;
+	s32			pre_syncpt_id;
+	u32			pre_syncpt_val;
+};
+
+struct tegra_fb_flip_data {
+	struct work_struct	work;
+	struct tegra_fb_info	*fb;
+	struct tegra_fb_flip_win windows[TEGRA_FB_FLIP_N_WINDOWS];
+	u32			syncpt_max;
 };
 
 /* palette array used by the fbcon */
@@ -55,6 +82,8 @@ static int tegra_fb_open(struct fb_info *info, int user)
 	if (atomic_xchg(&tegra_fb->in_use, 1))
 		return -EBUSY;
 
+	tegra_fb->user_nvmap = NULL;
+
 	return 0;
 }
 
@@ -62,6 +91,13 @@ static int tegra_fb_release(struct fb_info *info, int user)
 {
 	struct tegra_fb_info *tegra_fb = info->par;
 
+	flush_workqueue(tegra_fb->flip_wq);
+
+	if (tegra_fb->user_nvmap) {
+		nvmap_client_put(tegra_fb->user_nvmap);
+		tegra_fb->user_nvmap = NULL;
+	}
+
 	WARN_ON(!atomic_xchg(&tegra_fb->in_use, 0));
 
 	return 0;
@@ -215,6 +251,12 @@ static int tegra_fb_pan_display(struct fb_var_screeninfo *var,
 	tegra_dc_update_windows(&tegra_fb->win, 1);
 	tegra_dc_sync_windows(&tegra_fb->win, 1);
 
+	if (WARN_ON(tegra_fb->win->surface)) {
+		nvmap_unpin(tegra_fb->fb_nvmap, tegra_fb->win->surface);
+		nvmap_free(tegra_fb->fb_nvmap, tegra_fb->win->surface);
+		tegra_fb->win->surface = NULL;
+	}
+
 	return 0;
 }
 
@@ -236,6 +278,255 @@ static void tegra_fb_imageblit(struct fb_info *info,
 	cfb_imageblit(info, image);
 }
 
+/* TODO: implement ALLOC, FREE, BLANK ioctls */
+
+static int tegra_fb_set_nvmap_fd(struct tegra_fb_info *tegra_fb, int fd)
+{
+	struct nvmap_client *nvmap = NULL;
+
+	if (fd < 0)
+		return -EINVAL;
+
+	nvmap = nvmap_client_get_file(fd);
+	if (IS_ERR(nvmap))
+		return PTR_ERR(nvmap);
+
+	if (tegra_fb->user_nvmap)
+		nvmap_client_put(tegra_fb->user_nvmap);
+
+	tegra_fb->user_nvmap = nvmap;
+
+	return 0;
+}
+
+static int tegra_fb_set_windowattr(struct tegra_fb_info *tegra_fb,
+				   struct tegra_dc_win *win,
+				   const struct tegra_fb_windowattr *attr)
+{
+	struct nvmap_handle_ref *r_dupe;
+	struct nvmap_handle *h_win;
+
+	if (!attr->buff_id) {
+		win->flags = 0;
+		win->surface = NULL;
+		return 0;
+	}
+
+	h_win = nvmap_get_handle_id(tegra_fb->user_nvmap, attr->buff_id);
+	if (h_win == NULL) {
+		dev_err(&tegra_fb->ndev->dev, "%s: flip invalid "
+			"handle %08x\n", current->comm, attr->buff_id);
+		return -EPERM;
+	}
+
+	/* duplicate the new framebuffer's handle into the fb driver's
+	 * nvmap context, to ensure that the handle won't be freed as
+	 * long as it is in-use by the fb driver */
+	r_dupe = nvmap_duplicate_handle_id(tegra_fb->fb_nvmap, attr->buff_id);
+	nvmap_handle_put(h_win);
+
+	if (IS_ERR(r_dupe)) {
+		dev_err(&tegra_fb->ndev->dev, "couldn't duplicate handle\n");
+		return PTR_ERR(r_dupe);
+	}
+
+	win->surface = r_dupe;
+
+	win->flags = TEGRA_WIN_FLAG_ENABLED;
+	if (attr->blend == TEGRA_FB_WIN_BLEND_PREMULT)
+		win->flags |= TEGRA_WIN_FLAG_BLEND_PREMULT;
+	else if (attr->blend == TEGRA_FB_WIN_BLEND_COVERAGE)
+		win->flags |= TEGRA_WIN_FLAG_BLEND_COVERAGE;
+	win->fmt = attr->pixformat;
+	win->x = attr->x;
+	win->y = attr->y;
+	win->w = attr->w;
+	win->h = attr->h;
+	win->out_x = attr->out_x;
+	win->out_y = attr->out_y;
+	win->out_w = attr->out_w;
+	win->out_h = attr->out_h;
+	win->z = attr->z;
+
+	win->phys_addr = nvmap_pin(tegra_fb->fb_nvmap, r_dupe);
+	if (IS_ERR((void *)win->phys_addr)) {
+		dev_err(&tegra_fb->ndev->dev, "couldn't pin handle\n");
+		nvmap_free(tegra_fb->fb_nvmap, r_dupe);
+		return (int)win->phys_addr;
+	}
+	/* STOPSHIP verify that this won't read outside of the surface */
+	win->phys_addr += attr->offset;
+	win->stride = attr->stride;
+
+	return 0;
+}
+
+static void tegra_fb_flip_work(struct work_struct *work)
+{
+	struct tegra_fb_flip_data *data;
+	struct tegra_dc_win *wins[TEGRA_FB_FLIP_N_WINDOWS];
+	struct nvmap_handle_ref *surfs[TEGRA_FB_FLIP_N_WINDOWS];
+	int i, nr_win = 0, nr_unpin = 0;
+
+	data = container_of(work, struct tegra_fb_flip_data, work);
+
+	for (i = 0; i < TEGRA_FB_FLIP_N_WINDOWS; i++) {
+		struct tegra_fb_flip_win *flip_win = &data->windows[i];
+
+		if (!flip_win->dc_win)
+			continue;
+
+		if (flip_win->dc_win->flags && flip_win->dc_win->surface)
+			surfs[nr_unpin++] = flip_win->dc_win->surface;
+
+		wins[nr_win++] = flip_win->dc_win;
+
+		flip_win->dc_win->flags = flip_win->win_data.flags;
+		if (!flip_win->dc_win->flags)
+			continue;
+
+		flip_win->dc_win->surface = flip_win->win_data.surface;
+		flip_win->dc_win->fmt = flip_win->win_data.fmt;
+		flip_win->dc_win->x = flip_win->win_data.x;
+		flip_win->dc_win->y = flip_win->win_data.y;
+		flip_win->dc_win->w = flip_win->win_data.w;
+		flip_win->dc_win->h = flip_win->win_data.h;
+		flip_win->dc_win->out_x = flip_win->win_data.out_x;
+		flip_win->dc_win->out_y = flip_win->win_data.out_y;
+		flip_win->dc_win->out_w = flip_win->win_data.out_w;
+		flip_win->dc_win->out_h = flip_win->win_data.out_h;
+		flip_win->dc_win->z = flip_win->win_data.z;
+		flip_win->dc_win->phys_addr = flip_win->win_data.phys_addr;
+		flip_win->dc_win->stride = flip_win->win_data.stride;
+
+		if (flip_win->pre_syncpt_id < 0)
+			continue;
+
+		nvhost_syncpt_wait_timeout(&data->fb->ndev->host->syncpt,
+					   flip_win->pre_syncpt_id,
+					   flip_win->pre_syncpt_val,
+					   msecs_to_jiffies(500));
+	}
+
+	if (!nr_win)
+		goto free_data;
+
+	tegra_dc_update_windows(wins, nr_win);
+	/* TODO: implement swapinterval here */
+	tegra_dc_sync_windows(wins, nr_win);
+
+	tegra_dc_incr_syncpt_min(data->fb->win->dc, data->syncpt_max);
+
+	/* unpin and deref previous front buffers */
+	for (i = 0; i < nr_unpin; i++) {
+		nvmap_unpin(data->fb->fb_nvmap, surfs[i]);
+		nvmap_free(data->fb->fb_nvmap, surfs[i]);
+	}
+
+free_data:
+	kfree(data);
+}
+
+static int tegra_fb_flip(struct tegra_fb_info *tegra_fb,
+			 struct tegra_fb_flip_args *args)
+{
+	struct tegra_fb_flip_data *data;
+	struct tegra_fb_flip_win *flip_win;
+	struct tegra_dc *dc = tegra_fb->win->dc;
+	u32 syncpt_max;
+	int i, err;
+
+	if (WARN_ON(!tegra_fb->user_nvmap))
+		return -EFAULT;
+
+	if (WARN_ON(!tegra_fb->ndev))
+		return -EFAULT;
+
+	data = kmalloc(sizeof(*data), GFP_KERNEL);
+	if (!data) {
+		dev_err(&tegra_fb->ndev->dev, "no memory for flip\n");
+		return -ENOMEM;
+	}
+
+	INIT_WORK(&data->work, tegra_fb_flip_work);
+	data->fb = tegra_fb;
+
+	for (i = 0; i < TEGRA_FB_FLIP_N_WINDOWS; i++) {
+
+		flip_win = &data->windows[i];
+		flip_win->dc_win = tegra_dc_get_window(dc, args->win[i].index);
+		flip_win->pre_syncpt_id = args->win[i].pre_syncpt_id;
+		flip_win->pre_syncpt_val = args->win[i].pre_syncpt_val;
+
+		if (!flip_win->dc_win)
+			continue;
+
+		err = tegra_fb_set_windowattr(tegra_fb, &flip_win->win_data,
+					      &args->win[i]);
+		if (err) {
+			dev_err(&tegra_fb->ndev->dev, "error setting window "
+				"attributes\n");
+			goto surf_err;
+		}
+	}
+
+	syncpt_max = tegra_dc_incr_syncpt_max(dc);
+	data->syncpt_max = syncpt_max;
+
+	queue_work(tegra_fb->flip_wq, &data->work);
+
+	args->post_syncpt_val = syncpt_max;
+	args->post_syncpt_id = tegra_dc_get_syncpt_id(dc);
+
+	return 0;
+
+surf_err:
+	while (i--) {
+		if (data->windows[i].win_data.surface) {
+			nvmap_unpin(tegra_fb->fb_nvmap,
+				    data->windows[i].win_data.surface);
+			nvmap_free(tegra_fb->fb_nvmap,
+				   data->windows[i].win_data.surface);
+		}
+	}
+	kfree(data);
+	return err;
+}
+
+/* TODO: implement private window ioctls to set overlay x,y */
+
+static int tegra_fb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
+{
+	struct tegra_fb_info *tegra_fb = info->par;
+	struct tegra_fb_flip_args flip_args;
+	int fd;
+	int ret;
+
+	switch (cmd) {
+	case FBIO_TEGRA_SET_NVMAP_FD:
+		if (copy_from_user(&fd, (void __user *)arg, sizeof(fd)))
+			return -EFAULT;
+
+		return tegra_fb_set_nvmap_fd(tegra_fb, fd);
+
+	case FBIO_TEGRA_FLIP:
+		if (copy_from_user(&flip_args, (void __user *)arg, sizeof(flip_args)))
+			return -EFAULT;
+
+		ret = tegra_fb_flip(tegra_fb, &flip_args);
+
+		if (copy_to_user((void __user *)arg, &flip_args, sizeof(flip_args)))
+			return -EFAULT;
+
+		return ret;
+
+	default:
+		return -ENOTTY;
+	}
+
+	return 0;
+}
+
 static struct fb_ops tegra_fb_ops = {
 	.owner = THIS_MODULE,
 	.fb_open = tegra_fb_open,
@@ -248,6 +539,7 @@ static struct fb_ops tegra_fb_ops = {
 	.fb_fillrect = tegra_fb_fillrect,
 	.fb_copyarea = tegra_fb_copyarea,
 	.fb_imageblit = tegra_fb_imageblit,
+	.fb_ioctl = tegra_fb_ioctl,
 };
 
 void tegra_fb_update_monspecs(struct tegra_fb_info *fb_info,
@@ -316,8 +608,21 @@ struct tegra_fb_info *tegra_fb_register(struct nvhost_device *ndev,
 	tegra_fb->fb_mem = fb_mem;
 	tegra_fb->xres = fb_data->xres;
 	tegra_fb->yres = fb_data->yres;
+	tegra_fb->fb_nvmap = nvmap_create_client(nvmap_dev);
+	if (!tegra_fb->fb_nvmap) {
+		dev_err(&ndev->dev, "couldn't create nvmap client\n");
+		ret = -ENOMEM;
+		goto err_free;
+	}
 	atomic_set(&tegra_fb->in_use, 0);
 
+	tegra_fb->flip_wq = create_singlethread_workqueue(dev_name(&ndev->dev));
+	if (!tegra_fb->flip_wq) {
+		dev_err(&ndev->dev, "couldn't create flip work-queue\n");
+		ret = -ENOMEM;
+		goto err_delete_wq;
+	}
+
 	if (fb_mem) {
 		fb_size = resource_size(fb_mem);
 		fb_phys = fb_mem->start;
@@ -325,7 +630,7 @@ struct tegra_fb_info *tegra_fb_register(struct nvhost_device *ndev,
 		if (!fb_base) {
 			dev_err(&ndev->dev, "fb can't be mapped\n");
 			ret = -EBUSY;
-			goto err_free;
+			goto err_put_client;
 		}
 		tegra_fb->valid = true;
 	}
@@ -396,6 +701,10 @@ struct tegra_fb_info *tegra_fb_register(struct nvhost_device *ndev,
 
 err_iounmap_fb:
 	iounmap(fb_base);
+err_put_client:
+	nvmap_client_put(tegra_fb->fb_nvmap);
+err_delete_wq:
+	destroy_workqueue(tegra_fb->flip_wq);
 err_free:
 	framebuffer_release(info);
 err:
@@ -406,7 +715,19 @@ void tegra_fb_unregister(struct tegra_fb_info *fb_info)
 {
 	struct fb_info *info = fb_info->info;
 
+	if (fb_info->win->surface) {
+		nvmap_unpin(fb_info->fb_nvmap, fb_info->win->surface);
+		nvmap_free(fb_info->fb_nvmap, fb_info->win->surface);
+	}
+
+	if (fb_info->fb_nvmap)
+		nvmap_client_put(fb_info->fb_nvmap);
+
 	unregister_framebuffer(info);
+
+	flush_workqueue(fb_info->flip_wq);
+	destroy_workqueue(fb_info->flip_wq);
+
 	iounmap(info->screen_base);
 	framebuffer_release(info);
 }
diff --git a/include/video/tegrafb.h b/include/video/tegrafb.h
new file mode 100644
index 000000000000..3d7a5a9d66e9
--- /dev/null
+++ b/include/video/tegrafb.h
@@ -0,0 +1,83 @@
+/*
+ * include/video/tegrafb.h
+ *
+ * Copyright (C) 2010 Google, Inc.
+ * Author: Erik Gilling <konkers@android.com>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * 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.
+ *
+ */
+
+#ifndef _LINUX_TEGRAFB_H_
+#define _LINUX_TEGRAFB_H_
+
+#include <linux/types.h>
+#include <asm/ioctl.h>
+
+#define TEGRA_FB_WIN_FMT_P1		0
+#define TEGRA_FB_WIN_FMT_P2		1
+#define TEGRA_FB_WIN_FMT_P4		2
+#define TEGRA_FB_WIN_FMT_P8		3
+#define TEGRA_FB_WIN_FMT_B4G4R4A4	4
+#define TEGRA_FB_WIN_FMT_B5G5R5A	5
+#define TEGRA_FB_WIN_FMT_B5G6R5		6
+#define TEGRA_FB_WIN_FMT_AB5G5R5	7
+#define TEGRA_FB_WIN_FMT_B8G8R8A8	12
+#define TEGRA_FB_WIN_FMT_R8G8B8A8	13
+#define TEGRA_FB_WIN_FMT_B6x2G6x2R6x2A8	14
+#define TEGRA_FB_WIN_FMT_R6x2G6x2B6x2A8	15
+#define TEGRA_FB_WIN_FMT_YCbCr422	16
+#define TEGRA_FB_WIN_FMT_YUV422		17
+#define TEGRA_FB_WIN_FMT_YCbCr420P	18
+#define TEGRA_FB_WIN_FMT_YUV420P	19
+#define TEGRA_FB_WIN_FMT_YCbCr422P	20
+#define TEGRA_FB_WIN_FMT_YUV422P	21
+#define TEGRA_FB_WIN_FMT_YCbCr422R	22
+#define TEGRA_FB_WIN_FMT_YUV422R	23
+#define TEGRA_FB_WIN_FMT_YCbCr422RA	24
+#define TEGRA_FB_WIN_FMT_YUV422RA	25
+
+#define TEGRA_FB_WIN_BLEND_NONE	0
+#define TEGRA_FB_WIN_BLEND_PREMULT 1
+#define TEGRA_FB_WIN_BLEND_COVERAGE 2
+
+/* set index to -1 to ignore window data */
+struct tegra_fb_windowattr {
+	__s32	index;
+	__u32	buff_id;
+	__u32	blend;
+	__u32	offset;
+	__u32	stride;
+	__u32	pixformat;
+	__u32	x;
+	__u32	y;
+	__u32	w;
+	__u32	h;
+	__u32	out_x;
+	__u32	out_y;
+	__u32	out_w;
+	__u32	out_h;
+	__u32	z;
+	__u32	pre_syncpt_id;
+	__u32	pre_syncpt_val;
+};
+
+#define TEGRA_FB_FLIP_N_WINDOWS		3
+
+struct tegra_fb_flip_args {
+	struct tegra_fb_windowattr win[TEGRA_FB_FLIP_N_WINDOWS];
+	__u32 post_syncpt_id;
+	__u32 post_syncpt_val;
+};
+
+#define FBIO_TEGRA_SET_NVMAP_FD	_IOW('F', 0x40, __u32)
+#define FBIO_TEGRA_FLIP		_IOW('F', 0x41, struct tegra_fb_flip_args)
+
+#endif