drivers/media/video/tiler/tiler-geom.c - kernel/panda - Git at Google

 /*
  * tiler-geom.c
  *
  * TILER geometry functions for TI TILER hardware block.
  *
  * 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
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
  * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  */

 #include <linux/module.h>
 #include "_tiler.h"

 /* bits representing the same slot in DMM-TILER hw-block */
 #define SLOT_WIDTH_BITS		6
 #define SLOT_HEIGHT_BITS	6

 /* bits reserved to describe coordinates in DMM-TILER hw-block */
 #define CONT_WIDTH_BITS		14
 #define CONT_HEIGHT_BITS	13

 static struct tiler_geom geom[TILER_FORMATS] = {
 	{
 		.x_shft = 0,
 		.y_shft = 0,
 	},
 	{
 		.x_shft = 0,
 		.y_shft = 1,
 	},
 	{
 		.x_shft = 1,
 		.y_shft = 1,
 	},
 	{
 		.x_shft = SLOT_WIDTH_BITS,
 		.y_shft = SLOT_HEIGHT_BITS,
 	},
 };

 /* tiler space addressing bitfields */
 #define MASK_XY_FLIP		(1 << 31)
 #define MASK_Y_INVERT		(1 << 30)
 #define MASK_X_INVERT		(1 << 29)
 #define SHIFT_ACC_MODE		27
 #define MASK_ACC_MODE		3

 /* calculated constants */
 #define TILER_PAGE		(1 << (SLOT_WIDTH_BITS + SLOT_HEIGHT_BITS))
 #define TILER_WIDTH		(1 << (CONT_WIDTH_BITS - SLOT_WIDTH_BITS))
 #define TILER_HEIGHT		(1 << (CONT_HEIGHT_BITS - SLOT_HEIGHT_BITS))

 #define VIEW_SIZE		(1u << (CONT_WIDTH_BITS + CONT_HEIGHT_BITS))
 #define VIEW_MASK		(VIEW_SIZE - 1u)

 #define MASK(bits) ((1 << (bits)) - 1)

 #define TILER_FMT(x)	((enum tiler_fmt) \
 		((x >> SHIFT_ACC_MODE) & MASK_ACC_MODE))

 #define MASK_VIEW		(MASK_X_INVERT | MASK_Y_INVERT | MASK_XY_FLIP)

 /* location of the various tiler views in physical address space */
 #define TILVIEW_8BIT	0x60000000u
 #define TILVIEW_16BIT	(TILVIEW_8BIT  + VIEW_SIZE)
 #define TILVIEW_32BIT	(TILVIEW_16BIT + VIEW_SIZE)
 #define TILVIEW_PAGE	(TILVIEW_32BIT + VIEW_SIZE)
 #define TILVIEW_END	(TILVIEW_PAGE  + VIEW_SIZE)

 /* create tsptr by adding view orientation and access mode */
 #define TIL_ADDR(x, orient, a)\
 	((u32) (x) | (orient) | ((a) << SHIFT_ACC_MODE))

 bool is_tiler_addr(u32 phys)
 {
 	return phys >= TILVIEW_8BIT && phys < TILVIEW_END;
 }
 EXPORT_SYMBOL(is_tiler_addr);

 u32 tiler_bpp(const struct tiler_block_t *b)
 {
 	enum tiler_fmt fmt = tiler_fmt(b->phys);
 	BUG_ON(fmt == TILFMT_INVALID);

 	return geom[fmt].bpp_m;
 }
 EXPORT_SYMBOL(tiler_bpp);

 /* return the stride of a tiler-block in tiler space */
 static inline s32 tiler_stride(u32 tsptr)
 {
 	enum tiler_fmt fmt = TILER_FMT(tsptr);

 	if (fmt == TILFMT_PAGE)
 		return 0;
 	else if (tsptr & MASK_XY_FLIP)
 		return 1 << (CONT_HEIGHT_BITS + geom[fmt].x_shft);
 	else
 		return 1 << (CONT_WIDTH_BITS + geom[fmt].y_shft);
 }

 u32 tiler_pstride(const struct tiler_block_t *b)
 {
 	enum tiler_fmt fmt = tiler_fmt(b->phys);
 	BUG_ON(fmt == TILFMT_INVALID);

 	/* return the virtual stride for page mode */
 	if (fmt == TILFMT_PAGE)
 		return tiler_vstride(b);

 	return tiler_stride(b->phys & ~MASK_VIEW);
 }
 EXPORT_SYMBOL(tiler_pstride);

 enum tiler_fmt tiler_fmt(u32 phys)
 {
 	if (!is_tiler_addr(phys))
 		return TILFMT_INVALID;

 	return TILER_FMT(phys);
 }
 EXPORT_SYMBOL(tiler_fmt);

 /* returns the tiler geometry information for a format */
 static const struct tiler_geom *get_geom(enum tiler_fmt fmt)
 {
 	if (fmt >= TILFMT_MIN && fmt <= TILFMT_MAX)
 		return geom + fmt;
 	return NULL;
 }

 /**
  * Returns the natural x and y coordinates for a pixel in tiler space address.
  * That is, the coordinates for the same pixel in the natural (non-rotated,
  * non-mirrored) view. This allows to uniquely identify a tiler pixel in any
  * view orientation.
  */
 static void tiler_get_natural_xy(u32 tsptr, u32 *x, u32 *y)
 {
 	u32 x_bits, y_bits, offset;
 	enum tiler_fmt fmt;

 	fmt = TILER_FMT(tsptr);

 	x_bits = CONT_WIDTH_BITS - geom[fmt].x_shft;
 	y_bits = CONT_HEIGHT_BITS - geom[fmt].y_shft;
 	offset = (tsptr & VIEW_MASK) >> (geom[fmt].x_shft + geom[fmt].y_shft);

 	/* separate coordinate bitfields based on view orientation */
 	if (tsptr & MASK_XY_FLIP) {
 		*x = offset >> y_bits;
 		*y = offset & MASK(y_bits);
 	} else {
 		*x = offset & MASK(x_bits);
 		*y = offset >> x_bits;
 	}

 	/* account for mirroring */
 	if (tsptr & MASK_X_INVERT)
 		*x ^= MASK(x_bits);
 	if (tsptr & MASK_Y_INVERT)
 		*y ^= MASK(y_bits);
 }

 /* calculate the tiler space address of a pixel in a view orientation */
 static u32 tiler_get_address(u32 orient, enum tiler_fmt fmt, u32 x, u32 y)
 {
 	u32 x_bits, y_bits, tmp, x_mask, y_mask, alignment;

 	x_bits = CONT_WIDTH_BITS - geom[fmt].x_shft;
 	y_bits = CONT_HEIGHT_BITS - geom[fmt].y_shft;
 	alignment = geom[fmt].x_shft + geom[fmt].y_shft;

 	/* validate coordinate */
 	x_mask = MASK(x_bits);
 	y_mask = MASK(y_bits);
 	if (x < 0 || x > x_mask || y < 0 || y > y_mask)
 		return 0;

 	/* account for mirroring */
 	if (orient & MASK_X_INVERT)
 		x ^= x_mask;
 	if (orient & MASK_Y_INVERT)
 		y ^= y_mask;

 	/* get coordinate address */
 	if (orient & MASK_XY_FLIP)
 		tmp = ((x << y_bits) + y);
 	else
 		tmp = ((y << x_bits) + x);

 	return TIL_ADDR((tmp << alignment), orient, fmt);
 }

 void tilview_create(struct tiler_view_t *view, u32 phys, u32 width, u32 height)
 {
 	BUG_ON(!is_tiler_addr(phys));

 	view->tsptr = phys & ~MASK_VIEW;
 	view->bpp = geom[TILER_FMT(phys)].bpp_m;
 	view->width = width;
 	view->height = height;
 	view->h_inc = view->bpp;
 	view->v_inc = tiler_stride(view->tsptr);
 }
 EXPORT_SYMBOL(tilview_create);

 void tilview_get(struct tiler_view_t *view, struct tiler_block_t *blk)
 {
 	view->tsptr = blk->phys & ~MASK_VIEW;
 	view->bpp = tiler_bpp(blk);
 	view->width = blk->width;
 	view->height = blk->height;
 	view->h_inc = view->bpp;
 	view->v_inc = tiler_stride(view->tsptr);
 }
 EXPORT_SYMBOL(tilview_get);

 s32 tilview_crop(struct tiler_view_t *view, u32 left, u32 top, u32 width,
 								u32 height)
 {
 	/* check for valid crop */
 	if (left + width < left || left + width > view->width ||
 	    top + height < top || top + height > view->height)
 		return -EINVAL;

 	view->tsptr += left * view->h_inc + top * view->v_inc;
 	view->width = width;
 	view->height = height;
 	return 0;
 }
 EXPORT_SYMBOL(tilview_crop);

 /* calculate tilerspace address and stride after view orientation change */
 static void reorient(struct tiler_view_t *view, u32 orient)
 {
 	u32 x, y;

 	tiler_get_natural_xy(view->tsptr, &x, &y);
 	view->tsptr = tiler_get_address(orient,
 					TILER_FMT(view->tsptr), x, y);
 	view->v_inc = tiler_stride(view->tsptr);
 }

 s32 tilview_rotate(struct tiler_view_t *view, s32 rotation)
 {
 	u32 orient;

 	if (rotation % 90)
 		return -EINVAL;

 	/* normalize rotation to quarters */
 	rotation = (rotation / 90) & 3;
 	if (!rotation)
 		return 0; /* nothing to do */

 	/* PAGE mode view cannot be rotated */
 	if (TILER_FMT(view->tsptr) == TILFMT_PAGE)
 		return -EPERM;

 	/*
 	 * first adjust top-left corner. NOTE: it rotates counter-clockwise:
 	 * 0 < 3
 	 * v   ^
 	 * 1 > 2
 	 */
 	if (rotation < 3)
 		view->tsptr += (view->height - 1) * view->v_inc;
 	if (rotation > 1)
 		view->tsptr += (view->width - 1) * view->h_inc;

 	/* then rotate view itself */
 	orient = view->tsptr & MASK_VIEW;

 	/* rotate first 2 quarters */
 	if (rotation & 2) {
 		orient ^= MASK_X_INVERT;
 		orient ^= MASK_Y_INVERT;
 	}

 	/* rotate last quarter */
 	if (rotation & 1) {
 		orient ^= (orient & MASK_XY_FLIP) ?
 			MASK_X_INVERT : MASK_Y_INVERT;

 		/* swap x & y */
 		orient ^= MASK_XY_FLIP;
 		swap(view->height, view->width);
 	}

 	/* finally reorient view */
 	reorient(view, orient);
 	return 0;
 }
 EXPORT_SYMBOL(tilview_rotate);

 s32 tilview_flip(struct tiler_view_t *view, bool flip_x, bool flip_y)
 {
 	u32 orient;
 	orient = view->tsptr & MASK_VIEW;

 	if (!flip_x && !flip_y)
 		return 0; /* nothing to do */

 	/* PAGE mode view cannot be flipped */
 	if (TILER_FMT(view->tsptr) == TILFMT_PAGE)
 		return -EPERM;

 	/* adjust top-left corner */
 	if (flip_x)
 		view->tsptr += (view->width - 1) * view->h_inc;
 	if (flip_y)
 		view->tsptr += (view->height - 1) * view->v_inc;

 	/* flip view orientation */
 	if (orient & MASK_XY_FLIP)
 		swap(flip_x, flip_y);

 	if (flip_x)
 		orient ^= MASK_X_INVERT;
 	if (flip_y)
 		orient ^= MASK_Y_INVERT;

 	/* finally reorient view */
 	reorient(view, orient);
 	return 0;
 }
 EXPORT_SYMBOL(tilview_flip);

 /* return the alias address for a coordinate */
 static inline u32 alias_address(enum tiler_fmt fmt, u32 x, u32 y)
 {
 	return tiler_get_address(0, fmt, x, y) + TILVIEW_8BIT;
 }

 /* get the coordinates for an alias address */
 static inline void alias_xy(u32 ssptr, u32 *x, u32 *y)
 {
 	tiler_get_natural_xy(ssptr & ~MASK_VIEW, x, y);
 }

 /* initialize shared geometric data */
 void tiler_geom_init(struct tiler_ops *tiler)
 {
 	struct tiler_geom *g;

 	tiler->xy = alias_xy;
 	tiler->addr = alias_address;
 	tiler->geom = get_geom;

 	tiler->page   = TILER_PAGE;
 	tiler->width  = TILER_WIDTH;
 	tiler->height = TILER_HEIGHT;

 	/* calculate geometry */
 	for (g = geom; g < geom + TILER_FORMATS; g++) {
 		g->bpp_m = g->bpp = 1 << (g->x_shft + g->y_shft);
 		g->slot_w = 1 << (SLOT_WIDTH_BITS - g->x_shft);
 		g->slot_h = 1 << (SLOT_HEIGHT_BITS - g->y_shft);
 	}

 	/* set bpp_m = 1 for page mode as most applications deal in byte data */
 	geom[TILFMT_PAGE].bpp_m = 1;
 }
	/*
	* tiler-geom.c
	*
	* TILER geometry functions for TI TILER hardware block.
	*
	* 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
	* it under the terms of the GNU General Public License version 2 as
	* published by the Free Software Foundation.
	*
	* THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
	* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
	* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
	*/

	#include <linux/module.h>
	#include "_tiler.h"

	/* bits representing the same slot in DMM-TILER hw-block */
	#define SLOT_WIDTH_BITS 6
	#define SLOT_HEIGHT_BITS 6

	/* bits reserved to describe coordinates in DMM-TILER hw-block */
	#define CONT_WIDTH_BITS 14
	#define CONT_HEIGHT_BITS 13

	static struct tiler_geom geom[TILER_FORMATS] = {
	{
	.x_shft = 0,
	.y_shft = 0,
	},
	{
	.x_shft = 0,
	.y_shft = 1,
	},
	{
	.x_shft = 1,
	.y_shft = 1,
	},
	{
	.x_shft = SLOT_WIDTH_BITS,
	.y_shft = SLOT_HEIGHT_BITS,
	},
	};

	/* tiler space addressing bitfields */
	#define MASK_XY_FLIP (1 << 31)
	#define MASK_Y_INVERT (1 << 30)
	#define MASK_X_INVERT (1 << 29)
	#define SHIFT_ACC_MODE 27
	#define MASK_ACC_MODE 3

	/* calculated constants */
	#define TILER_PAGE (1 << (SLOT_WIDTH_BITS + SLOT_HEIGHT_BITS))
	#define TILER_WIDTH (1 << (CONT_WIDTH_BITS - SLOT_WIDTH_BITS))
	#define TILER_HEIGHT (1 << (CONT_HEIGHT_BITS - SLOT_HEIGHT_BITS))

	#define VIEW_SIZE (1u << (CONT_WIDTH_BITS + CONT_HEIGHT_BITS))
	#define VIEW_MASK (VIEW_SIZE - 1u)

	#define MASK(bits) ((1 << (bits)) - 1)

	#define TILER_FMT(x) ((enum tiler_fmt) \
	((x >> SHIFT_ACC_MODE) & MASK_ACC_MODE))

	#define MASK_VIEW (MASK_X_INVERT \| MASK_Y_INVERT \| MASK_XY_FLIP)

	/* location of the various tiler views in physical address space */
	#define TILVIEW_8BIT 0x60000000u
	#define TILVIEW_16BIT (TILVIEW_8BIT + VIEW_SIZE)
	#define TILVIEW_32BIT (TILVIEW_16BIT + VIEW_SIZE)
	#define TILVIEW_PAGE (TILVIEW_32BIT + VIEW_SIZE)
	#define TILVIEW_END (TILVIEW_PAGE + VIEW_SIZE)

	/* create tsptr by adding view orientation and access mode */
	#define TIL_ADDR(x, orient, a)\
	((u32) (x) \| (orient) \| ((a) << SHIFT_ACC_MODE))

	bool is_tiler_addr(u32 phys)
	{
	return phys >= TILVIEW_8BIT && phys < TILVIEW_END;
	}
	EXPORT_SYMBOL(is_tiler_addr);

	u32 tiler_bpp(const struct tiler_block_t *b)
	{
	enum tiler_fmt fmt = tiler_fmt(b->phys);
	BUG_ON(fmt == TILFMT_INVALID);

	return geom[fmt].bpp_m;
	}
	EXPORT_SYMBOL(tiler_bpp);

	/* return the stride of a tiler-block in tiler space */
	static inline s32 tiler_stride(u32 tsptr)
	{
	enum tiler_fmt fmt = TILER_FMT(tsptr);

	if (fmt == TILFMT_PAGE)
	return 0;
	else if (tsptr & MASK_XY_FLIP)
	return 1 << (CONT_HEIGHT_BITS + geom[fmt].x_shft);
	else
	return 1 << (CONT_WIDTH_BITS + geom[fmt].y_shft);
	}

	u32 tiler_pstride(const struct tiler_block_t *b)
	{
	enum tiler_fmt fmt = tiler_fmt(b->phys);
	BUG_ON(fmt == TILFMT_INVALID);

	/* return the virtual stride for page mode */
	if (fmt == TILFMT_PAGE)
	return tiler_vstride(b);

	return tiler_stride(b->phys & ~MASK_VIEW);
	}
	EXPORT_SYMBOL(tiler_pstride);

	enum tiler_fmt tiler_fmt(u32 phys)
	{
	if (!is_tiler_addr(phys))
	return TILFMT_INVALID;

	return TILER_FMT(phys);
	}
	EXPORT_SYMBOL(tiler_fmt);

	/* returns the tiler geometry information for a format */
	static const struct tiler_geom *get_geom(enum tiler_fmt fmt)
	{
	if (fmt >= TILFMT_MIN && fmt <= TILFMT_MAX)
	return geom + fmt;
	return NULL;
	}

	/**
	* Returns the natural x and y coordinates for a pixel in tiler space address.
	* That is, the coordinates for the same pixel in the natural (non-rotated,
	* non-mirrored) view. This allows to uniquely identify a tiler pixel in any
	* view orientation.
	*/
	static void tiler_get_natural_xy(u32 tsptr, u32 x, u32 y)
	{
	u32 x_bits, y_bits, offset;
	enum tiler_fmt fmt;

	fmt = TILER_FMT(tsptr);

	x_bits = CONT_WIDTH_BITS - geom[fmt].x_shft;
	y_bits = CONT_HEIGHT_BITS - geom[fmt].y_shft;
	offset = (tsptr & VIEW_MASK) >> (geom[fmt].x_shft + geom[fmt].y_shft);

	/* separate coordinate bitfields based on view orientation */
	if (tsptr & MASK_XY_FLIP) {
	*x = offset >> y_bits;
	*y = offset & MASK(y_bits);
	} else {
	*x = offset & MASK(x_bits);
	*y = offset >> x_bits;
	}

	/* account for mirroring */
	if (tsptr & MASK_X_INVERT)
	*x ^= MASK(x_bits);
	if (tsptr & MASK_Y_INVERT)
	*y ^= MASK(y_bits);
	}

	/* calculate the tiler space address of a pixel in a view orientation */
	static u32 tiler_get_address(u32 orient, enum tiler_fmt fmt, u32 x, u32 y)
	{
	u32 x_bits, y_bits, tmp, x_mask, y_mask, alignment;

	x_bits = CONT_WIDTH_BITS - geom[fmt].x_shft;
	y_bits = CONT_HEIGHT_BITS - geom[fmt].y_shft;
	alignment = geom[fmt].x_shft + geom[fmt].y_shft;

	/* validate coordinate */
	x_mask = MASK(x_bits);
	y_mask = MASK(y_bits);
	if (x < 0 \|\| x > x_mask \|\| y < 0 \|\| y > y_mask)
	return 0;

	/* account for mirroring */
	if (orient & MASK_X_INVERT)
	x ^= x_mask;
	if (orient & MASK_Y_INVERT)
	y ^= y_mask;

	/* get coordinate address */
	if (orient & MASK_XY_FLIP)
	tmp = ((x << y_bits) + y);
	else
	tmp = ((y << x_bits) + x);

	return TIL_ADDR((tmp << alignment), orient, fmt);
	}

	void tilview_create(struct tiler_view_t *view, u32 phys, u32 width, u32 height)
	{
	BUG_ON(!is_tiler_addr(phys));

	view->tsptr = phys & ~MASK_VIEW;
	view->bpp = geom[TILER_FMT(phys)].bpp_m;
	view->width = width;
	view->height = height;
	view->h_inc = view->bpp;
	view->v_inc = tiler_stride(view->tsptr);
	}
	EXPORT_SYMBOL(tilview_create);

	void tilview_get(struct tiler_view_t view, struct tiler_block_t blk)
	{
	view->tsptr = blk->phys & ~MASK_VIEW;
	view->bpp = tiler_bpp(blk);
	view->width = blk->width;
	view->height = blk->height;
	view->h_inc = view->bpp;
	view->v_inc = tiler_stride(view->tsptr);
	}
	EXPORT_SYMBOL(tilview_get);

	s32 tilview_crop(struct tiler_view_t *view, u32 left, u32 top, u32 width,
	u32 height)
	{
	/* check for valid crop */
	if (left + width < left \|\| left + width > view->width \|\|
	top + height < top \|\| top + height > view->height)
	return -EINVAL;

	view->tsptr += left * view->h_inc + top * view->v_inc;
	view->width = width;
	view->height = height;
	return 0;
	}
	EXPORT_SYMBOL(tilview_crop);

	/* calculate tilerspace address and stride after view orientation change */
	static void reorient(struct tiler_view_t *view, u32 orient)
	{
	u32 x, y;

	tiler_get_natural_xy(view->tsptr, &x, &y);
	view->tsptr = tiler_get_address(orient,
	TILER_FMT(view->tsptr), x, y);
	view->v_inc = tiler_stride(view->tsptr);
	}

	s32 tilview_rotate(struct tiler_view_t *view, s32 rotation)
	{
	u32 orient;

	if (rotation % 90)
	return -EINVAL;

	/* normalize rotation to quarters */
	rotation = (rotation / 90) & 3;
	if (!rotation)
	return 0; /* nothing to do */

	/* PAGE mode view cannot be rotated */
	if (TILER_FMT(view->tsptr) == TILFMT_PAGE)
	return -EPERM;

	/*
	* first adjust top-left corner. NOTE: it rotates counter-clockwise:
	* 0 < 3
	* v ^
	* 1 > 2
	*/
	if (rotation < 3)
	view->tsptr += (view->height - 1) * view->v_inc;
	if (rotation > 1)
	view->tsptr += (view->width - 1) * view->h_inc;

	/* then rotate view itself */
	orient = view->tsptr & MASK_VIEW;

	/* rotate first 2 quarters */
	if (rotation & 2) {
	orient ^= MASK_X_INVERT;
	orient ^= MASK_Y_INVERT;
	}

	/* rotate last quarter */
	if (rotation & 1) {
	orient ^= (orient & MASK_XY_FLIP) ?
	MASK_X_INVERT : MASK_Y_INVERT;

	/* swap x & y */
	orient ^= MASK_XY_FLIP;
	swap(view->height, view->width);
	}

	/* finally reorient view */
	reorient(view, orient);
	return 0;
	}
	EXPORT_SYMBOL(tilview_rotate);

	s32 tilview_flip(struct tiler_view_t *view, bool flip_x, bool flip_y)
	{
	u32 orient;
	orient = view->tsptr & MASK_VIEW;

	if (!flip_x && !flip_y)
	return 0; /* nothing to do */

	/* PAGE mode view cannot be flipped */
	if (TILER_FMT(view->tsptr) == TILFMT_PAGE)
	return -EPERM;

	/* adjust top-left corner */
	if (flip_x)
	view->tsptr += (view->width - 1) * view->h_inc;
	if (flip_y)
	view->tsptr += (view->height - 1) * view->v_inc;

	/* flip view orientation */
	if (orient & MASK_XY_FLIP)
	swap(flip_x, flip_y);

	if (flip_x)
	orient ^= MASK_X_INVERT;
	if (flip_y)
	orient ^= MASK_Y_INVERT;

	/* finally reorient view */
	reorient(view, orient);
	return 0;
	}
	EXPORT_SYMBOL(tilview_flip);

	/* return the alias address for a coordinate */
	static inline u32 alias_address(enum tiler_fmt fmt, u32 x, u32 y)
	{
	return tiler_get_address(0, fmt, x, y) + TILVIEW_8BIT;
	}

	/* get the coordinates for an alias address */
	static inline void alias_xy(u32 ssptr, u32 x, u32 y)
	{
	tiler_get_natural_xy(ssptr & ~MASK_VIEW, x, y);
	}

	/* initialize shared geometric data */
	void tiler_geom_init(struct tiler_ops *tiler)
	{
	struct tiler_geom *g;

	tiler->xy = alias_xy;
	tiler->addr = alias_address;
	tiler->geom = get_geom;

	tiler->page = TILER_PAGE;
	tiler->width = TILER_WIDTH;
	tiler->height = TILER_HEIGHT;

	/* calculate geometry */
	for (g = geom; g < geom + TILER_FORMATS; g++) {
	g->bpp_m = g->bpp = 1 << (g->x_shft + g->y_shft);
	g->slot_w = 1 << (SLOT_WIDTH_BITS - g->x_shft);
	g->slot_h = 1 << (SLOT_HEIGHT_BITS - g->y_shft);
	}

	/* set bpp_m = 1 for page mode as most applications deal in byte data */
	geom[TILFMT_PAGE].bpp_m = 1;
	}