--- /dev/null
+Index: xserver/hw/kdrive/glamo/Makefile.am
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ xserver/hw/kdrive/glamo/Makefile.am 2007-09-25 19:32:10.000000000 +0800
+@@ -0,0 +1,51 @@
++if KDRIVEFBDEV
++FBDEV_INCLUDES =-I$(top_srcdir)/hw/kdrive/fbdev
++FBDEV_LIBS = $(top_builddir)/hw/kdrive/fbdev/libfbdev.a
++endif
++
++if KDRIVEVESA
++VESA_INCLUDES = -I$(top_srcdir)/hw/kdrive/vesa
++VESA_LIBS = $(top_builddir)/hw/kdrive/vesa/libvesa.a
++endif
++
++INCLUDES = \
++ @KDRIVE_INCS@ \
++ $(DRI_INCLUDES) \
++ $(FBDEV_INCLUDES) \
++ $(VESA_INCLUDES) \
++ @KDRIVE_CFLAGS@
++
++bin_PROGRAMS = Xglamo
++
++noinst_LIBRARIES = libglamo.a
++
++libglamo_a_SOURCES = \
++ glamo_dma.c \
++ glamo_dma.h \
++ glamo_draw.c \
++ glamo_draw.h \
++ glamo.c \
++ glamo.h \
++ glamo-regs.h \
++ glamo_video.c
++
++Xglamo_SOURCES = \
++ glamo_stub.c
++
++GLAMO_LIBS = \
++ libglamo.a \
++ $(FBDEV_LIBS) \
++ $(VESA_LIBS) \
++ $(DRI_LIBS) \
++ @KDRIVE_LIBS@
++
++Xglamo_LDADD = \
++ $(GLAMO_LIBS) \
++ @KDRIVE_LIBS@
++
++Xglamo_DEPENDENCIES = \
++ libglamo.a \
++ @KDRIVE_LOCAL_LIBS@
++
++relink:
++ rm -f $(bin_PROGRAMS) && make $(bin_PROGRAMS)
+Index: xserver/hw/kdrive/glamo/glamo-regs.h
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ xserver/hw/kdrive/glamo/glamo-regs.h 2007-09-25 19:00:20.000000000 +0800
+@@ -0,0 +1,685 @@
++#ifndef _GLAMO_REGS_H
++#define _GLAMO_REGS_H
++
++/* Smedia Glamo 336x/337x driver
++ *
++ * (C) 2007 by OpenMoko, Inc.
++ * Author: Harald Welte <laforge@openmoko.org>
++ * All rights reserved.
++ *
++ * This program is free software; you can redistribute it and/or
++ * modify it under the terms of the GNU General Public License as
++ * published by the Free Software Foundation; either version 2 of
++ * the License, or (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
++ * MA 02111-1307 USA
++ */
++
++enum glamo_regster_offsets {
++ GLAMO_REGOFS_GENERIC = 0x0000,
++ GLAMO_REGOFS_HOSTBUS = 0x0200,
++ GLAMO_REGOFS_MEMORY = 0x0300,
++ GLAMO_REGOFS_VIDCAP = 0x0400,
++ GLAMO_REGOFS_ISP = 0x0500,
++ GLAMO_REGOFS_JPEG = 0x0800,
++ GLAMO_REGOFS_MPEG = 0x0c00,
++ GLAMO_REGOFS_LCD = 0x1100,
++ GLAMO_REGOFS_MMC = 0x1400,
++ GLAMO_REGOFS_MPROC0 = 0x1500,
++ GLAMO_REGOFS_MPROC1 = 0x1580,
++ GLAMO_REGOFS_CMDQUEUE = 0x1600,
++ GLAMO_REGOFS_RISC = 0x1680,
++ GLAMO_REGOFS_2D = 0x1700,
++ GLAMO_REGOFS_3D = 0x1b00,
++};
++
++
++enum glamo_register_generic {
++ GLAMO_REG_GCONF1 = 0x0000,
++ GLAMO_REG_GCONF2 = 0x0002,
++#define GLAMO_REG_DEVICE_ID GLAMO_REG_GCONF2
++ GLAMO_REG_GCONF3 = 0x0004,
++#define GLAMO_REG_REVISION_ID GLAMO_REG_GCONF3
++ GLAMO_REG_IRQ_GEN1 = 0x0006,
++#define GLAMO_REG_IRQ_ENABLE GLAMO_REG_IRQ_GEN1
++ GLAMO_REG_IRQ_GEN2 = 0x0008,
++#define GLAMO_REG_IRQ_SET GLAMO_REG_IRQ_GEN2
++ GLAMO_REG_IRQ_GEN3 = 0x000a,
++#define GLAMO_REG_IRQ_CLEAR GLAMO_REG_IRQ_GEN3
++ GLAMO_REG_IRQ_GEN4 = 0x000c,
++#define GLAMO_REG_IRQ_STATUS GLAMO_REG_IRQ_GEN4
++ GLAMO_REG_CLOCK_HOST = 0x0010,
++ GLAMO_REG_CLOCK_MEMORY = 0x0012,
++ GLAMO_REG_CLOCK_LCD = 0x0014,
++ GLAMO_REG_CLOCK_MMC = 0x0016,
++ GLAMO_REG_CLOCK_ISP = 0x0018,
++ GLAMO_REG_CLOCK_JPEG = 0x001a,
++ GLAMO_REG_CLOCK_3D = 0x001c,
++ GLAMO_REG_CLOCK_2D = 0x001e,
++ GLAMO_REG_CLOCK_RISC1 = 0x0020, /* 3365 only? */
++ GLAMO_REG_CLOCK_RISC2 = 0x0022, /* 3365 only? */
++ GLAMO_REG_CLOCK_MPEG = 0x0024,
++ GLAMO_REG_CLOCK_MPROC = 0x0026,
++
++ GLAMO_REG_CLOCK_GEN5_1 = 0x0030,
++ GLAMO_REG_CLOCK_GEN5_2 = 0x0032,
++ GLAMO_REG_CLOCK_GEN6 = 0x0034,
++ GLAMO_REG_CLOCK_GEN7 = 0x0036,
++ GLAMO_REG_CLOCK_GEN8 = 0x0038,
++ GLAMO_REG_CLOCK_GEN9 = 0x003a,
++ GLAMO_REG_CLOCK_GEN10 = 0x003c,
++ GLAMO_REG_CLOCK_GEN11 = 0x003e,
++ GLAMO_REG_PLL_GEN1 = 0x0040,
++ GLAMO_REG_PLL_GEN2 = 0x0042,
++ GLAMO_REG_PLL_GEN3 = 0x0044,
++ GLAMO_REG_PLL_GEN4 = 0x0046,
++ GLAMO_REG_PLL_GEN5 = 0x0048,
++ GLAMO_REG_GPIO_GEN1 = 0x0050,
++ GLAMO_REG_GPIO_GEN2 = 0x0052,
++ GLAMO_REG_GPIO_GEN3 = 0x0054,
++ GLAMO_REG_GPIO_GEN4 = 0x0056,
++ GLAMO_REG_GPIO_GEN5 = 0x0058,
++ GLAMO_REG_GPIO_GEN6 = 0x005a,
++ GLAMO_REG_GPIO_GEN7 = 0x005c,
++ GLAMO_REG_GPIO_GEN8 = 0x005e,
++ GLAMO_REG_GPIO_GEN9 = 0x0060,
++ GLAMO_REG_GPIO_GEN10 = 0x0062,
++ GLAMO_REG_DFT_GEN1 = 0x0070,
++ GLAMO_REG_DFT_GEN2 = 0x0072,
++ GLAMO_REG_DFT_GEN3 = 0x0074,
++ GLAMO_REG_DFT_GEN4 = 0x0076,
++
++ GLAMO_REG_DFT_GEN5 = 0x01e0,
++ GLAMO_REG_DFT_GEN6 = 0x01f0,
++};
++
++#define GLAMO_REG_HOSTBUS(x) (GLAMO_REGOFS_HOSTBUS-2+(x*2))
++
++#define REG_MEM(x) (GLAMO_REGOFS_MEMORY+(x))
++#define GLAMO_REG_MEM_TIMING(x) (GLAMO_REG_MEM_TIMING1-2+(x*2))
++
++enum glamo_register_mem {
++ GLAMO_REG_MEM_TYPE = REG_MEM(0x00),
++ GLAMO_REG_MEM_GEN = REG_MEM(0x02),
++ GLAMO_REG_MEM_TIMING1 = REG_MEM(0x04),
++ GLAMO_REG_MEM_TIMING2 = REG_MEM(0x06),
++ GLAMO_REG_MEM_TIMING3 = REG_MEM(0x08),
++ GLAMO_REG_MEM_TIMING4 = REG_MEM(0x0a),
++ GLAMO_REG_MEM_TIMING5 = REG_MEM(0x0c),
++ GLAMO_REG_MEM_TIMING6 = REG_MEM(0x0e),
++ GLAMO_REG_MEM_TIMING7 = REG_MEM(0x10),
++ GLAMO_REG_MEM_TIMING8 = REG_MEM(0x12),
++ GLAMO_REG_MEM_TIMING9 = REG_MEM(0x14),
++ GLAMO_REG_MEM_TIMING10 = REG_MEM(0x16),
++ GLAMO_REG_MEM_TIMING11 = REG_MEM(0x18),
++ GLAMO_REG_MEM_POWER1 = REG_MEM(0x1a),
++ GLAMO_REG_MEM_POWER2 = REG_MEM(0x1c),
++ GLAMO_REG_MEM_LCD_BUF1 = REG_MEM(0x1e),
++ GLAMO_REG_MEM_LCD_BUF2 = REG_MEM(0x20),
++ GLAMO_REG_MEM_LCD_BUF3 = REG_MEM(0x22),
++ GLAMO_REG_MEM_LCD_BUF4 = REG_MEM(0x24),
++ GLAMO_REG_MEM_BIST1 = REG_MEM(0x26),
++ GLAMO_REG_MEM_BIST2 = REG_MEM(0x28),
++ GLAMO_REG_MEM_BIST3 = REG_MEM(0x2a),
++ GLAMO_REG_MEM_BIST4 = REG_MEM(0x2c),
++ GLAMO_REG_MEM_BIST5 = REG_MEM(0x2e),
++ GLAMO_REG_MEM_MAH1 = REG_MEM(0x30),
++ GLAMO_REG_MEM_MAH2 = REG_MEM(0x32),
++ GLAMO_REG_MEM_DRAM1 = REG_MEM(0x34),
++ GLAMO_REG_MEM_DRAM2 = REG_MEM(0x36),
++ GLAMO_REG_MEM_CRC = REG_MEM(0x38),
++};
++
++#define GLAMO_MEM_TYPE_MASK 0x03
++
++enum glamo_reg_mem_dram1 {
++ GLAMO_MEM_DRAM1_EN_SDRAM_CLK = (1 << 11),
++ GLAMO_MEM_DRAM1_SELF_REFRESH = (1 << 12),
++};
++
++enum glamo_reg_mem_dram2 {
++ GLAMO_MEM_DRAM2_DEEP_PWRDOWN = (1 << 12),
++};
++
++enum glamo_irq {
++ GLAMO_IRQ_HOSTBUS = 0x0001,
++ GLAMO_IRQ_JPEG = 0x0002,
++ GLAMO_IRQ_MPEG = 0x0004,
++ GLAMO_IRQ_MPROC1 = 0x0008,
++ GLAMO_IRQ_MPROC0 = 0x0010,
++ GLAMO_IRQ_CMDQUEUE = 0x0020,
++ GLAMO_IRQ_2D = 0x0040,
++ GLAMO_IRQ_MMC = 0x0080,
++ GLAMO_IRQ_RISC = 0x0100,
++};
++
++enum glamo_reg_clock_host {
++ GLAMO_CLOCK_HOST_DG_BCLK = 0x0001,
++ GLAMO_CLOCK_HOST_DG_M0CLK = 0x0004,
++ GLAMO_CLOCK_HOST_RESET = 0x1000,
++};
++
++enum glamo_reg_clock_mem {
++ GLAMO_CLOCK_MEM_DG_M1CLK = 0x0001,
++ GLAMO_CLOCK_MEM_EN_M1CLK = 0x0002,
++ GLAMO_CLOCK_MEM_DG_MOCACLK = 0x0004,
++ GLAMO_CLOCK_MEM_EN_MOCACLK = 0x0008,
++ GLAMO_CLOCK_MEM_RESET = 0x1000,
++ GLAMO_CLOCK_MOCA_RESET = 0x2000,
++};
++
++enum glamo_reg_clock_lcd {
++ GLAMO_CLOCK_LCD_DG_DCLK = 0x0001,
++ GLAMO_CLOCK_LCD_EN_DCLK = 0x0002,
++ GLAMO_CLOCK_LCD_DG_DMCLK = 0x0004,
++ GLAMO_CLOCK_LCD_EN_DMCLK = 0x0008,
++ //
++ GLAMO_CLOCK_LCD_EN_DHCLK = 0x0020,
++ GLAMO_CLOCK_LCD_DG_M5CLK = 0x0040,
++ GLAMO_CLOCK_LCD_EN_M5CLK = 0x0080,
++ GLAMO_CLOCK_LCD_RESET = 0x1000,
++};
++
++enum glamo_reg_clock_mmc {
++ GLAMO_CLOCK_MMC_DG_TCLK = 0x0001,
++ GLAMO_CLOCK_MMC_EN_TCLK = 0x0002,
++ GLAMO_CLOCK_MMC_DG_M9CLK = 0x0004,
++ GLAMO_CLOCK_MMC_EN_M9CLK = 0x0008,
++ GLAMO_CLOCK_MMC_RESET = 0x1000,
++};
++
++enum glamo_reg_clock_isp {
++ GLAMO_CLOCK_ISP_DG_I1CLK = 0x0001,
++ GLAMO_CLOCK_ISP_EN_I1CLK = 0x0002,
++ GLAMO_CLOCK_ISP_DG_CCLK = 0x0004,
++ GLAMO_CLOCK_ISP_EN_CCLK = 0x0008,
++ //
++ GLAMO_CLOCK_ISP_EN_SCLK = 0x0020,
++ GLAMO_CLOCK_ISP_DG_M2CLK = 0x0040,
++ GLAMO_CLOCK_ISP_EN_M2CLK = 0x0080,
++ GLAMO_CLOCK_ISP_DG_M15CLK = 0x0100,
++ GLAMO_CLOCK_ISP_EN_M15CLK = 0x0200,
++ GLAMO_CLOCK_ISP1_RESET = 0x1000,
++ GLAMO_CLOCK_ISP2_RESET = 0x2000,
++};
++
++enum glamo_reg_clock_jpeg {
++ GLAMO_CLOCK_JPEG_DG_JCLK = 0x0001,
++ GLAMO_CLOCK_JPEG_EN_JCLK = 0x0002,
++ GLAMO_CLOCK_JPEG_DG_M3CLK = 0x0004,
++ GLAMO_CLOCK_JPEG_EN_M3CLK = 0x0008,
++ GLAMO_CLOCK_JPEG_RESET = 0x1000,
++};
++
++enum glamo_reg_clock_2d {
++ GLAMO_CLOCK_2D_DG_GCLK = 0x0001,
++ GLAMO_CLOCK_2D_EN_GCLK = 0x0002,
++ GLAMO_CLOCK_2D_DG_M7CLK = 0x0004,
++ GLAMO_CLOCK_2D_EN_M7CLK = 0x0008,
++ GLAMO_CLOCK_2D_DG_M6CLK = 0x0010,
++ GLAMO_CLOCK_2D_EN_M6CLK = 0x0020,
++ GLAMO_CLOCK_2D_RESET = 0x1000,
++ GLAMO_CLOCK_2D_CQ_RESET = 0x2000,
++};
++
++enum glamo_reg_clock_3d {
++ GLAMO_CLOCK_3D_DG_ECLK = 0x0001,
++ GLAMO_CLOCK_3D_EN_ECLK = 0x0002,
++ GLAMO_CLOCK_3D_DG_RCLK = 0x0004,
++ GLAMO_CLOCK_3D_EN_RCLK = 0x0008,
++ GLAMO_CLOCK_3D_DG_M8CLK = 0x0010,
++ GLAMO_CLOCK_3D_EN_M8CLK = 0x0020,
++ GLAMO_CLOCK_3D_BACK_RESET = 0x1000,
++ GLAMO_CLOCK_3D_FRONT_RESET = 0x2000,
++};
++
++enum glamo_reg_clock_mpeg {
++ GLAMO_CLOCK_MPEG_DG_X0CLK = 0x0001,
++ GLAMO_CLOCK_MPEG_EN_X0CLK = 0x0002,
++ GLAMO_CLOCK_MPEG_DG_X1CLK = 0x0004,
++ GLAMO_CLOCK_MPEG_EN_X1CLK = 0x0008,
++ GLAMO_CLOCK_MPEG_DG_X2CLK = 0x0010,
++ GLAMO_CLOCK_MPEG_EN_X2CLK = 0x0020,
++ GLAMO_CLOCK_MPEG_DG_X3CLK = 0x0040,
++ GLAMO_CLOCK_MPEG_EN_X3CLK = 0x0080,
++ GLAMO_CLOCK_MPEG_DG_X4CLK = 0x0100,
++ GLAMO_CLOCK_MPEG_EN_X4CLK = 0x0200,
++ GLAMO_CLOCK_MPEG_DG_X6CLK = 0x0400,
++ GLAMO_CLOCK_MPEG_EN_X6CLK = 0x0800,
++ GLAMO_CLOCK_MPEG_ENC_RESET = 0x1000,
++ GLAMO_CLOCK_MPEG_DEC_RESET = 0x2000,
++};
++
++enum glamo_reg_clock51 {
++ GLAMO_CLOCK_GEN51_EN_DIV_MCLK = 0x0001,
++ GLAMO_CLOCK_GEN51_EN_DIV_SCLK = 0x0002,
++ GLAMO_CLOCK_GEN51_EN_DIV_JCLK = 0x0004,
++ GLAMO_CLOCK_GEN51_EN_DIV_DCLK = 0x0008,
++ GLAMO_CLOCK_GEN51_EN_DIV_DMCLK = 0x0010,
++ GLAMO_CLOCK_GEN51_EN_DIV_DHCLK = 0x0020,
++ GLAMO_CLOCK_GEN51_EN_DIV_GCLK = 0x0040,
++ GLAMO_CLOCK_GEN51_EN_DIV_TCLK = 0x0080,
++ /* FIXME: higher bits */
++};
++
++enum glamo_reg_clock52 {
++ GLAMO_CLOCK_GEN52_EN_DIV_ACLK = 0x0001,
++ GLAMO_CLOCK_GEN52_EN_DIV_AMCLK = 0x0002,
++ GLAMO_CLOCK_GEN52_EN_DIV_OCLK = 0x0004,
++ GLAMO_CLOCK_GEN52_EN_DIV_ZCLK = 0x0008,
++ GLAMO_CLOCK_GEN52_EN_DIV_ICLK = 0x0010,
++ /* FIXME: higher bits */
++};
++
++enum glamo_reg_hostbus2 {
++ GLAMO_HOSTBUS2_MMIO_EN_ISP = 0x0001,
++ GLAMO_HOSTBUS2_MMIO_EN_JPEG = 0x0002,
++ GLAMO_HOSTBUS2_MMIO_EN_MPEG = 0x0004,
++ GLAMO_HOSTBUS2_MMIO_EN_LCD = 0x0008,
++ GLAMO_HOSTBUS2_MMIO_EN_MMC = 0x0010,
++ GLAMO_HOSTBUS2_MMIO_EN_MICROP0 = 0x0020,
++ GLAMO_HOSTBUS2_MMIO_EN_MICROP1 = 0x0040,
++ GLAMO_HOSTBUS2_MMIO_EN_CQ = 0x0080,
++ GLAMO_HOSTBUS2_MMIO_EN_RISC = 0x0100,
++ GLAMO_HOSTBUS2_MMIO_EN_2D = 0x0200,
++ GLAMO_HOSTBUS2_MMIO_EN_3D = 0x0400,
++};
++
++/* LCD Controller */
++
++#define REG_LCD(x) (x)
++enum glamo_reg_lcd {
++ GLAMO_REG_LCD_MODE1 = REG_LCD(0x00),
++ GLAMO_REG_LCD_MODE2 = REG_LCD(0x02),
++ GLAMO_REG_LCD_MODE3 = REG_LCD(0x04),
++ GLAMO_REG_LCD_WIDTH = REG_LCD(0x06),
++ GLAMO_REG_LCD_HEIGHT = REG_LCD(0x08),
++ GLAMO_REG_LCD_POLARITY = REG_LCD(0x0a),
++ GLAMO_REG_LCD_A_BASE1 = REG_LCD(0x0c),
++ GLAMO_REG_LCD_A_BASE2 = REG_LCD(0x0e),
++ GLAMO_REG_LCD_B_BASE1 = REG_LCD(0x10),
++ GLAMO_REG_LCD_B_BASE2 = REG_LCD(0x12),
++ GLAMO_REG_LCD_C_BASE1 = REG_LCD(0x14),
++ GLAMO_REG_LCD_C_BASE2 = REG_LCD(0x16),
++ GLAMO_REG_LCD_PITCH = REG_LCD(0x18),
++ /* RES */
++ GLAMO_REG_LCD_HORIZ_TOTAL = REG_LCD(0x1c),
++ /* RES */
++ GLAMO_REG_LCD_HORIZ_RETR_START = REG_LCD(0x20),
++ /* RES */
++ GLAMO_REG_LCD_HORIZ_RETR_END = REG_LCD(0x24),
++ /* RES */
++ GLAMO_REG_LCD_HORIZ_DISP_START = REG_LCD(0x28),
++ /* RES */
++ GLAMO_REG_LCD_HORIZ_DISP_END = REG_LCD(0x2c),
++ /* RES */
++ GLAMO_REG_LCD_VERT_TOTAL = REG_LCD(0x30),
++ /* RES */
++ GLAMO_REG_LCD_VERT_RETR_START = REG_LCD(0x34),
++ /* RES */
++ GLAMO_REG_LCD_VERT_RETR_END = REG_LCD(0x38),
++ /* RES */
++ GLAMO_REG_LCD_VERT_DISP_START = REG_LCD(0x3c),
++ /* RES */
++ GLAMO_REG_LCD_VERT_DISP_END = REG_LCD(0x40),
++ /* RES */
++ GLAMO_REG_LCD_POL = REG_LCD(0x44),
++ GLAMO_REG_LCD_DATA_START = REG_LCD(0x46),
++ GLAMO_REG_LCD_FRATE_CONTRO = REG_LCD(0x48),
++ GLAMO_REG_LCD_DATA_CMD_HDR = REG_LCD(0x4a),
++ GLAMO_REG_LCD_SP_START = REG_LCD(0x4c),
++ GLAMO_REG_LCD_SP_END = REG_LCD(0x4e),
++ GLAMO_REG_LCD_CURSOR_BASE1 = REG_LCD(0x50),
++ GLAMO_REG_LCD_CURSOR_BASE2 = REG_LCD(0x52),
++ GLAMO_REG_LCD_CURSOR_PITCH = REG_LCD(0x54),
++ GLAMO_REG_LCD_CURSOR_X_SIZE = REG_LCD(0x56),
++ GLAMO_REG_LCD_CURSOR_Y_SIZE = REG_LCD(0x58),
++ GLAMO_REG_LCD_CURSOR_X_POS = REG_LCD(0x5a),
++ GLAMO_REG_LCD_CURSOR_Y_POS = REG_LCD(0x5c),
++ GLAMO_REG_LCD_CURSOR_PRESET = REG_LCD(0x5e),
++ GLAMO_REG_LCD_CURSOR_FG_COLOR = REG_LCD(0x60),
++ /* RES */
++ GLAMO_REG_LCD_CURSOR_BG_COLOR = REG_LCD(0x64),
++ /* RES */
++ GLAMO_REG_LCD_CURSOR_DST_COLOR = REG_LCD(0x68),
++ /* RES */
++ GLAMO_REG_LCD_STATUS1 = REG_LCD(0x80),
++ GLAMO_REG_LCD_STATUS2 = REG_LCD(0x82),
++ GLAMO_REG_LCD_STATUS3 = REG_LCD(0x84),
++ GLAMO_REG_LCD_STATUS4 = REG_LCD(0x86),
++ /* RES */
++ GLAMO_REG_LCD_COMMAND1 = REG_LCD(0xa0),
++ GLAMO_REG_LCD_COMMAND2 = REG_LCD(0xa2),
++ /* RES */
++ GLAMO_REG_LCD_WFORM_DELAY1 = REG_LCD(0xb0),
++ GLAMO_REG_LCD_WFORM_DELAY2 = REG_LCD(0xb2),
++ /* RES */
++ GLAMO_REG_LCD_GAMMA_CORR = REG_LCD(0x100),
++ /* RES */
++ GLAMO_REG_LCD_GAMMA_R_ENTRY01 = REG_LCD(0x110),
++ GLAMO_REG_LCD_GAMMA_R_ENTRY23 = REG_LCD(0x112),
++ GLAMO_REG_LCD_GAMMA_R_ENTRY45 = REG_LCD(0x114),
++ GLAMO_REG_LCD_GAMMA_R_ENTRY67 = REG_LCD(0x116),
++ GLAMO_REG_LCD_GAMMA_R_ENTRY8 = REG_LCD(0x118),
++ /* RES */
++ GLAMO_REG_LCD_GAMMA_G_ENTRY01 = REG_LCD(0x130),
++ GLAMO_REG_LCD_GAMMA_G_ENTRY23 = REG_LCD(0x132),
++ GLAMO_REG_LCD_GAMMA_G_ENTRY45 = REG_LCD(0x134),
++ GLAMO_REG_LCD_GAMMA_G_ENTRY67 = REG_LCD(0x136),
++ GLAMO_REG_LCD_GAMMA_G_ENTRY8 = REG_LCD(0x138),
++ /* RES */
++ GLAMO_REG_LCD_GAMMA_B_ENTRY01 = REG_LCD(0x150),
++ GLAMO_REG_LCD_GAMMA_B_ENTRY23 = REG_LCD(0x152),
++ GLAMO_REG_LCD_GAMMA_B_ENTRY45 = REG_LCD(0x154),
++ GLAMO_REG_LCD_GAMMA_B_ENTRY67 = REG_LCD(0x156),
++ GLAMO_REG_LCD_GAMMA_B_ENTRY8 = REG_LCD(0x158),
++ /* RES */
++ GLAMO_REG_LCD_SRAM_DRIVING1 = REG_LCD(0x160),
++ GLAMO_REG_LCD_SRAM_DRIVING2 = REG_LCD(0x162),
++ GLAMO_REG_LCD_SRAM_DRIVING3 = REG_LCD(0x164),
++};
++
++enum glamo_reg_lcd_mode1 {
++ GLAMO_LCD_MODE1_PWRSAVE = 0x0001,
++ GLAMO_LCD_MODE1_PARTIAL_PRT = 0x0002,
++ GLAMO_LCD_MODE1_HWFLIP = 0x0004,
++ GLAMO_LCD_MODE1_LCD2 = 0x0008,
++ /* RES */
++ GLAMO_LCD_MODE1_PARTIAL_MODE = 0x0020,
++ GLAMO_LCD_MODE1_CURSOR_DSTCOLOR = 0x0040,
++ GLAMO_LCD_MODE1_PARTIAL_ENABLE = 0x0080,
++ GLAMO_LCD_MODE1_TVCLK_IN_ENABLE = 0x0100,
++ GLAMO_LCD_MODE1_HSYNC_HIGH_ACT = 0x0200,
++ GLAMO_LCD_MODE1_VSYNC_HIGH_ACT = 0x0400,
++ GLAMO_LCD_MODE1_HSYNC_FLIP = 0x0800,
++ GLAMO_LCD_MODE1_GAMMA_COR_EN = 0x1000,
++ GLAMO_LCD_MODE1_DITHER_EN = 0x2000,
++ GLAMO_LCD_MODE1_CURSOR_EN = 0x4000,
++ GLAMO_LCD_MODE1_ROTATE_EN = 0x8000,
++};
++
++enum glamo_reg_lcd_mode2 {
++ GLAMO_LCD_MODE2_CRC_CHECK_EN = 0x0001,
++ GLAMO_LCD_MODE2_DCMD_PER_LINE = 0x0002,
++ GLAMO_LCD_MODE2_NOUSE_BDEF = 0x0004,
++ GLAMO_LCD_MODE2_OUT_POS_MODE = 0x0008,
++ GLAMO_LCD_MODE2_FRATE_CTRL_EN = 0x0010,
++ GLAMO_LCD_MODE2_SINGLE_BUFFER = 0x0020,
++ GLAMO_LCD_MODE2_SER_LSB_TO_MSB = 0x0040,
++ /* FIXME */
++};
++
++enum glamo_reg_lcd_mode3 {
++ /* LCD color source data format */
++ GLAMO_LCD_SRC_RGB565 = 0x0000,
++ GLAMO_LCD_SRC_ARGB1555 = 0x4000,
++ GLAMO_LCD_SRC_ARGB4444 = 0x8000,
++ /* interface type */
++ GLAMO_LCD_MODE3_LCD = 0x1000,
++ GLAMO_LCD_MODE3_RGB = 0x0800,
++ GLAMO_LCD_MODE3_CPU = 0x0000,
++ /* mode */
++ GLAMO_LCD_MODE3_RGB332 = 0x0000,
++ GLAMO_LCD_MODE3_RGB444 = 0x0100,
++ GLAMO_LCD_MODE3_RGB565 = 0x0200,
++ GLAMO_LCD_MODE3_RGB666 = 0x0300,
++ /* depth */
++ GLAMO_LCD_MODE3_6BITS = 0x0000,
++ GLAMO_LCD_MODE3_8BITS = 0x0010,
++ GLAMO_LCD_MODE3_9BITS = 0x0020,
++ GLAMO_LCD_MODE3_16BITS = 0x0030,
++ GLAMO_LCD_MODE3_18BITS = 0x0040,
++};
++
++enum glamo_lcd_cmd_type {
++ GLAMO_LCD_CMD_TYPE_DISP = 0x0000,
++ GLAMO_LCD_CMD_TYPE_PARALLEL = 0x4000,
++ GLAMO_LCD_CMD_TYPE_SERIAL = 0x8000,
++ GLAMO_LCD_CMD_TYPE_SERIAL_DIRECT= 0xc000,
++};
++#define GLAMO_LCD_CMD_TYPE_MASK 0xc000
++
++enum glamo_lcd_cmds {
++ GLAMO_LCD_CMD_DATA_DISP_FIRE = 0x00,
++ GLAMO_LCD_CMD_DATA_DISP_SYNC = 0x01, /* RGB only */
++ /* switch to command mode, no display */
++ GLAMO_LCD_CMD_DATA_FIRE_NO_DISP = 0x02,
++ /* display until VSYNC, switch to command */
++ GLAMO_LCD_CMD_DATA_FIRE_VSYNC = 0x11,
++ /* display until HSYNC, switch to command */
++ GLAMO_LCD_CMD_DATA_FIRE_HSYNC = 0x12,
++ /* display until VSYNC, 1 black frame, VSYNC, switch to command */
++ GLAMO_LCD_CMD_DATA_FIRE_VSYNC_B = 0x13,
++ /* don't care about display and switch to command */
++ GLAMO_LCD_CMD_DATA_FIRE_FREE = 0x14, /* RGB only */
++ /* don't care about display, keep data display but disable data,
++ * and switch to command */
++ GLAMO_LCD_CMD_DATA_FIRE_FREE_D = 0x15, /* RGB only */
++};
++
++enum glamo_core_revisions {
++ GLAMO_CORE_REV_A0 = 0x0000,
++ GLAMO_CORE_REV_A1 = 0x0001,
++ GLAMO_CORE_REV_A2 = 0x0002,
++ GLAMO_CORE_REV_A3 = 0x0003,
++};
++
++#define REG_ISP(x) (GLAMO_REGOFS_ISP+(x))
++
++enum glamo_register_isp {
++ GLAMO_REG_ISP_EN1 = REG_ISP(0x00),
++ GLAMO_REG_ISP_EN2 = REG_ISP(0x02),
++ GLAMO_REG_ISP_EN3 = REG_ISP(0x04),
++ GLAMO_REG_ISP_EN4 = REG_ISP(0x06),
++ GLAMO_REG_ISP_CAP_0_ADDRL = REG_ISP(0x08),
++ GLAMO_REG_ISP_CAP_0_ADDRH = REG_ISP(0x0a),
++ GLAMO_REG_ISP_CAP_1_ADDRL = REG_ISP(0x0c),
++ GLAMO_REG_ISP_CAP_1_ADDRH = REG_ISP(0x0e),
++ GLAMO_REG_ISP_DEC_Y_ADDRL = REG_ISP(0x10),
++ GLAMO_REG_ISP_DEC_Y_ADDRH = REG_ISP(0x12),
++ GLAMO_REG_ISP_DEC_U_ADDRL = REG_ISP(0x14),
++ GLAMO_REG_ISP_DEC_U_ADDRH = REG_ISP(0x16),
++ GLAMO_REG_ISP_DEC_V_ADDRL = REG_ISP(0x18),
++ GLAMO_REG_ISP_DEC_V_ADDRH = REG_ISP(0x1a),
++ GLAMO_REG_ISP_CAP_SEG_HEIGHT = REG_ISP(0x1c),
++ GLAMO_REG_ISP_CAP_PITCH = REG_ISP(0x1e),
++ GLAMO_REG_ISP_CAP_HEIGHT = REG_ISP(0x20),
++ GLAMO_REG_ISP_CAP_WIDTH = REG_ISP(0x22),
++ GLAMO_REG_ISP_DEC_PITCH_Y = REG_ISP(0x24),
++ GLAMO_REG_ISP_DEC_PITCH_UV = REG_ISP(0x26),
++ GLAMO_REG_ISP_DEC_HEIGHT = REG_ISP(0x28),
++ GLAMO_REG_ISP_DEC_WIDTH = REG_ISP(0x2a),
++ GLAMO_REG_ISP_ONFLY_MODE1 = REG_ISP(0x2c),
++ GLAMO_REG_ISP_ONFLY_MODE2 = REG_ISP(0x2e),
++ GLAMO_REG_ISP_ONFLY_MODE3 = REG_ISP(0x30),
++ GLAMO_REG_ISP_ONFLY_MODE4 = REG_ISP(0x32),
++ GLAMO_REG_ISP_ONFLY_MODE5 = REG_ISP(0x34),
++ //
++ GLAMO_REG_ISP_YUV2RGB_11 = REG_ISP(0x50),
++ GLAMO_REG_ISP_YUV2RGB_21 = REG_ISP(0x52),
++ GLAMO_REG_ISP_YUV2RGB_32 = REG_ISP(0x54),
++ GLAMO_REG_ISP_YUV2RGB_33 = REG_ISP(0x56),
++ GLAMO_REG_ISP_YUV2RGB_RG = REG_ISP(0x58),
++ GLAMO_REG_ISP_YUV2RGB_B = REG_ISP(0x5a),
++ //
++ GLAMO_REG_ISP_PORT1_SCALEH = REG_ISP(0x76),
++ GLAMO_REG_ISP_PORT1_SCALEV = REG_ISP(0x78),
++ GLAMO_REG_ISP_PORT2_SCALEH = REG_ISP(0x7a),
++ GLAMO_REG_ISP_PORT2_SCALEV = REG_ISP(0x7c),
++ GLAMO_REG_ISP_DEC_SCALEH = REG_ISP(0x7e),
++ GLAMO_REG_ISP_DEC_SCALEV = REG_ISP(0x80),
++ GLAMO_REG_ISP_TURBO = REG_ISP(0x82),
++ GLAMO_REG_ISP_PORT1_CAP_EN = REG_ISP(0x84),
++ GLAMO_REG_ISP_PORT1_CAP_0_ADDRL = REG_ISP(0x86),
++ GLAMO_REG_ISP_PORT1_CAP_0_ADDRH = REG_ISP(0x88),
++ GLAMO_REG_ISP_PORT1_CAP_1_ADDRL = REG_ISP(0x8a),
++ GLAMO_REG_ISP_PORT1_CAP_1_ADDRH = REG_ISP(0x8c),
++ GLAMO_REG_ISP_PORT1_CAP_WIDTH = REG_ISP(0x8e),
++ GLAMO_REG_ISP_PORT1_CAP_HEIGHT = REG_ISP(0x90),
++ GLAMO_REG_ISP_PORT1_CAP_PITCH = REG_ISP(0x92),
++ GLAMO_REG_ISP_PORT1_CAP_CLIP_L = REG_ISP(0x94),
++ GLAMO_REG_ISP_PORT1_CAP_CLIP_R = REG_ISP(0x96),
++ GLAMO_REG_ISP_PORT1_CAP_CLIP_T = REG_ISP(0x98),
++ GLAMO_REG_ISP_PORT1_CAP_CLIP_B = REG_ISP(0x9a),
++ GLAMO_REG_ISP_PORT1_DEC_EN = REG_ISP(0x9c),
++ GLAMO_REG_ISP_PORT1_DEC_0_ADDRL = REG_ISP(0x9e),
++ GLAMO_REG_ISP_PORT1_DEC_0_ADDRH = REG_ISP(0xa0),
++ GLAMO_REG_ISP_PORT1_DEC_1_ADDRL = REG_ISP(0xa2),
++ GLAMO_REG_ISP_PORT1_DEC_1_ADDRH = REG_ISP(0xa4),
++ GLAMO_REG_ISP_PORT1_DEC_WIDTH = REG_ISP(0xa6),
++ GLAMO_REG_ISP_PORT1_DEC_HEIGHT = REG_ISP(0xa8),
++ GLAMO_REG_ISP_PORT1_DEC_PITCH = REG_ISP(0xaa),
++ GLAMO_REG_ISP_PORT1_DEC_CLIP_L = REG_ISP(0xac),
++ GLAMO_REG_ISP_PORT1_DEC_CLIP_R = REG_ISP(0xae),
++ GLAMO_REG_ISP_PORT1_DEC_CLIP_T = REG_ISP(0xb0),
++ GLAMO_REG_ISP_PORT1_DEC_CLIP_B = REG_ISP(0xb2),
++ GLAMO_REG_ISP_PORT2_EN = REG_ISP(0xb4),
++ GLAMO_REG_ISP_PORT2_0_Y_ADDRL = REG_ISP(0xb6),
++ GLAMO_REG_ISP_PORT2_0_Y_ADDRH = REG_ISP(0xb8),
++ GLAMO_REG_ISP_PORT2_0_U_ADDRL = REG_ISP(0xba),
++ GLAMO_REG_ISP_PORT2_0_U_ADDRH = REG_ISP(0xbc),
++ GLAMO_REG_ISP_PORT2_0_V_ADDRL = REG_ISP(0xbe),
++ GLAMO_REG_ISP_PORT2_0_V_ADDRH = REG_ISP(0xc0),
++ GLAMO_REG_ISP_PORT2_1_Y_ADDRL = REG_ISP(0xc2),
++ GLAMO_REG_ISP_PORT2_1_Y_ADDRH = REG_ISP(0xc4),
++ GLAMO_REG_ISP_PORT2_1_U_ADDRL = REG_ISP(0xc6),
++ GLAMO_REG_ISP_PORT2_1_U_ADDRH = REG_ISP(0xc8),
++ GLAMO_REG_ISP_PORT2_1_V_ADDRL = REG_ISP(0xca),
++ GLAMO_REG_ISP_PORT2_1_V_ADDRH = REG_ISP(0xcc),
++ GLAMO_REG_ISP_PORT2_2_Y_ADDRL = REG_ISP(0xce),
++ GLAMO_REG_ISP_PORT2_2_Y_ADDRH = REG_ISP(0xd0),
++ GLAMO_REG_ISP_PORT2_2_U_ADDRL = REG_ISP(0xd2),
++ GLAMO_REG_ISP_PORT2_2_U_ADDRH = REG_ISP(0xd4),
++ GLAMO_REG_ISP_PORT2_2_V_ADDRL = REG_ISP(0xd6),
++ GLAMO_REG_ISP_PORT2_2_V_ADDRH = REG_ISP(0xd8),
++ GLAMO_REG_ISP_PORT2_WIDTH = REG_ISP(0xda),
++ GLAMO_REG_ISP_PORT2_HEIGHT = REG_ISP(0xdc),
++ GLAMO_REG_ISP_PORT2_Y_PITCH = REG_ISP(0xde),
++ GLAMO_REG_ISP_PORT2_UV_PITCH = REG_ISP(0xe0),
++ //
++ GLAMO_REG_ISP_RGB2YUV_11_12 = REG_ISP(0xf6),
++ GLAMO_REG_ISP_RGB2YUV_13_21 = REG_ISP(0xf8),
++ GLAMO_REG_ISP_RGB2YUV_22_23 = REG_ISP(0xfa),
++ GLAMO_REG_ISP_RGB2YUV_31_32 = REG_ISP(0xfc),
++ GLAMO_REG_ISP_RGB2YUV_33 = REG_ISP(0xfe),
++ //
++ GLAMO_REG_ISP_PORT1_SCALEH_MATRIX = REG_ISP(0x10c),
++ //
++ GLAMO_REG_ISP_PORT1_SCALEV_MATRIX = REG_ISP(0x120),
++ //
++ GLAMO_REG_ISP_PORT2_SCALEH_MATRIX = REG_ISP(0x134),
++ //
++ GLAMO_REG_ISP_PORT2_SCALEV_MATRIX = REG_ISP(0x148),
++ //
++ GLAMO_REG_ISP_DEC_SCALEH_MATRIX = REG_ISP(0x15c),
++ //
++ GLAMO_REG_ISP_DEC_SCALEV_MATRIX = REG_ISP(0x170),
++ //
++ GLAMO_REG_ISP_STATUS = REG_ISP(0x184),
++};
++
++enum glamo_reg_isp_en1 {
++ GLAMO_ISP_EN1_FIRE_ISP = 0x0001,
++ GLAMO_ISP_EN1_FIRE_CAP = 0x0002,
++ GLAMO_ISP_EN1_VIDEO_CONF = 0x0004,
++ GLAMO_ISP_EN1_BAYER_SRC = 0x0008,
++ //
++ GLAMO_ISP_EN1_YUV_PACK = 0x0040,
++ GLAMO_ISP_EN1_PLANE_MODE = 0x0080,
++ GLAMO_ISP_EN1_YUV_INPUT = 0x0100,
++ GLAMO_ISP_EN1_YUV420 = 0x0200,
++ //
++};
++
++enum glamo_reg_isp_en3 {
++ //
++ GLAMO_ISP_EN3_SCALE_IMPROVE = 0x0040,
++ GLAMO_ISP_EN3_PLANE_MODE = 0x0080,
++ GLAMO_ISP_EN3_YUV_INPUT = 0x0100,
++ GLAMO_ISP_EN3_YUV420 = 0x0200,
++ //
++};
++
++enum glamo_reg_isp_port1_en {
++ GLAMO_ISP_PORT1_EN_OUTPUT = 0x0001,
++// GLAMO_ISP_PORT1_EN_SCALE = 0x0002,
++ GLAMO_ISP_PORT1_EN_CLIP = 0x0004,
++ GLAMO_ISP_PORT1_EN_CLIP_OUT = 0x0008,
++ GLAMO_ISP_PORT1_EN_DUAL_BUF = 0x0010,
++};
++
++enum glamo_reg_isp_port2_en {
++ GLAMO_ISP_PORT2_EN_OUTPUT = 0x0001,
++ GLAMO_ISP_PORT2_EN_SCALE = 0x0002,
++ GLAMO_ISP_PORT2_EN_JPEG = 0x0010,
++ GLAMO_ISP_PORT2_EN_MPEG = 0x0020,
++ GLAMO_ISP_PORT2_EN_ENCODE = 0x0040,
++ GLAMO_ISP_PORT2_EN_DECODE = 0x0080,
++};
++
++#define REG_CQ(x) (GLAMO_REGOFS_CMDQUEUE+(x))
++
++enum glamo_register_cq {
++ GLAMO_REG_CQ_BASE_ADDRL = REG_CQ(0x00),
++ GLAMO_REG_CQ_BASE_ADDRH = REG_CQ(0x02),
++ GLAMO_REG_CQ_LEN = REG_CQ(0x04),
++ GLAMO_REG_CQ_WRITE_ADDRL = REG_CQ(0x06),
++ GLAMO_REG_CQ_WRITE_ADDRH = REG_CQ(0x08),
++ GLAMO_REG_CQ_FLIP = REG_CQ(0x0a),
++ GLAMO_REG_CQ_CONTROL = REG_CQ(0x0c),
++ GLAMO_REG_CQ_READ_ADDRL = REG_CQ(0x0e),
++ GLAMO_REG_CQ_READ_ADDRH = REG_CQ(0x10),
++ GLAMO_REG_CQ_STATUS = REG_CQ(0x12),
++};
++
++#define REG_2D(x) (GLAMO_REGOFS_2D+(x))
++
++enum glamo_register_2d {
++ GLAMO_REG_2D_SRC_ADDRL = REG_2D(0x00),
++ GLAMO_REG_2D_SRC_ADDRH = REG_2D(0x02),
++ GLAMO_REG_2D_SRC_PITCH = REG_2D(0x04),
++ GLAMO_REG_2D_SRC_X = REG_2D(0x06),
++ GLAMO_REG_2D_SRC_Y = REG_2D(0x08),
++ GLAMO_REG_2D_DST_X = REG_2D(0x0a),
++ GLAMO_REG_2D_DST_Y = REG_2D(0x0c),
++ GLAMO_REG_2D_DST_ADDRL = REG_2D(0x0e),
++ GLAMO_REG_2D_DST_ADDRH = REG_2D(0x10),
++ GLAMO_REG_2D_DST_PITCH = REG_2D(0x12),
++ GLAMO_REG_2D_DST_HEIGHT = REG_2D(0x14),
++ GLAMO_REG_2D_RECT_WIDTH = REG_2D(0x16),
++ GLAMO_REG_2D_RECT_HEIGHT = REG_2D(0x18),
++ GLAMO_REG_2D_PAT_ADDRL = REG_2D(0x1a),
++ GLAMO_REG_2D_PAT_ADDRH = REG_2D(0x1c),
++ GLAMO_REG_2D_PAT_FG = REG_2D(0x1e),
++ GLAMO_REG_2D_PAT_BG = REG_2D(0x20),
++ GLAMO_REG_2D_SRC_FG = REG_2D(0x22),
++ GLAMO_REG_2D_SRC_BG = REG_2D(0x24),
++ GLAMO_REG_2D_MASK1 = REG_2D(0x26),
++ GLAMO_REG_2D_MASK2 = REG_2D(0x28),
++ GLAMO_REG_2D_MASK3 = REG_2D(0x2a),
++ GLAMO_REG_2D_MASK4 = REG_2D(0x2c),
++ GLAMO_REG_2D_ROT_X = REG_2D(0x2e),
++ GLAMO_REG_2D_ROT_Y = REG_2D(0x30),
++ GLAMO_REG_2D_LEFT_CLIP = REG_2D(0x32),
++ GLAMO_REG_2D_TOP_CLIP = REG_2D(0x34),
++ GLAMO_REG_2D_RIGHT_CLIP = REG_2D(0x36),
++ GLAMO_REG_2D_BOTTOM_CLIP = REG_2D(0x38),
++ GLAMO_REG_2D_COMMAND1 = REG_2D(0x3A),
++ GLAMO_REG_2D_COMMAND2 = REG_2D(0x3C),
++ GLAMO_REG_2D_COMMAND3 = REG_2D(0x3E),
++ GLAMO_REG_2D_SAFE = REG_2D(0x40),
++ GLAMO_REG_2D_STATUS = REG_2D(0x42),
++ GLAMO_REG_2D_ID1 = REG_2D(0x44),
++ GLAMO_REG_2D_ID2 = REG_2D(0x46),
++ GLAMO_REG_2D_ID3 = REG_2D(0x48),
++};
++
++#endif /* _GLAMO_REGS_H */
+Index: xserver/hw/kdrive/glamo/glamo.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ xserver/hw/kdrive/glamo/glamo.c 2007-09-26 17:44:47.000000000 +0800
+@@ -0,0 +1,498 @@
++/*
++ * Copyright © 2007 OpenMoko, Inc.
++ *
++ * This driver is based on Xati,
++ * Copyright © 2003 Eric Anholt
++ *
++ * Permission to use, copy, modify, distribute, and sell this software and its
++ * documentation for any purpose is hereby granted without fee, provided that
++ * the above copyright notice appear in all copies and that both that copyright
++ * notice and this permission notice appear in supporting documentation, and
++ * that the name of the copyright holders not be used in advertising or
++ * publicity pertaining to distribution of the software without specific,
++ * written prior permission. The copyright holders make no representations
++ * about the suitability of this software for any purpose. It is provided "as
++ * is" without express or implied warranty.
++ *
++ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
++ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
++ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
++ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
++ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
++ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
++ * OF THIS SOFTWARE.
++ */
++
++#ifdef HAVE_CONFIG_H
++#include <kdrive-config.h>
++#endif
++#include "glamo.h"
++#if defined(USE_DRI) && defined(GLXEXT)
++#include "glamo_sarea.h"
++#endif
++
++static Bool
++GLAMOCardInit(KdCardInfo *card)
++{
++ GLAMOCardInfo *glamoc;
++ Bool initialized = FALSE;
++
++ glamoc = xcalloc(sizeof(GLAMOCardInfo), 1);
++ if (glamoc == NULL)
++ return FALSE;
++
++#ifdef KDRIVEFBDEV
++ if (!initialized && fbdevInitialize(card, &glamoc->backend_priv.fbdev)) {
++ glamoc->use_fbdev = TRUE;
++ initialized = TRUE;
++ glamoc->backend_funcs.cardfini = fbdevCardFini;
++ glamoc->backend_funcs.scrfini = fbdevScreenFini;
++ glamoc->backend_funcs.initScreen = fbdevInitScreen;
++ glamoc->backend_funcs.finishInitScreen = fbdevFinishInitScreen;
++ glamoc->backend_funcs.createRes = fbdevCreateResources;
++ glamoc->backend_funcs.preserve = fbdevPreserve;
++ glamoc->backend_funcs.restore = fbdevRestore;
++ glamoc->backend_funcs.dpms = fbdevDPMS;
++ glamoc->backend_funcs.enable = fbdevEnable;
++ glamoc->backend_funcs.disable = fbdevDisable;
++ glamoc->backend_funcs.getColors = fbdevGetColors;
++ glamoc->backend_funcs.putColors = fbdevPutColors;
++#ifdef RANDR
++ glamoc->backend_funcs.randrSetConfig = fbdevRandRSetConfig;
++#endif
++ }
++#endif
++#ifdef KDRIVEVESA
++ if (!initialized && vesaInitialize(card, &glamoc->backend_priv.vesa)) {
++ glamoc->use_vesa = TRUE;
++ initialized = TRUE;
++ glamoc->backend_funcs.cardfini = vesaCardFini;
++ glamoc->backend_funcs.scrfini = vesaScreenFini;
++ glamoc->backend_funcs.initScreen = vesaInitScreen;
++ glamoc->backend_funcs.finishInitScreen = vesaFinishInitScreen;
++ glamoc->backend_funcs.createRes = vesaCreateResources;
++ glamoc->backend_funcs.preserve = vesaPreserve;
++ glamoc->backend_funcs.restore = vesaRestore;
++ glamoc->backend_funcs.dpms = vesaDPMS;
++ glamoc->backend_funcs.enable = vesaEnable;
++ glamoc->backend_funcs.disable = vesaDisable;
++ glamoc->backend_funcs.getColors = vesaGetColors;
++ glamoc->backend_funcs.putColors = vesaPutColors;
++#ifdef RANDR
++ glamoc->backend_funcs.randrSetConfig = vesaRandRSetConfig;
++#endif
++ }
++#endif
++
++ if (!initialized || !GLAMOMapReg(card, glamoc)) {
++ xfree(glamoc);
++ return FALSE;
++ }
++
++#ifdef USE_DRI
++ /* We demand identification by busid, not driver name */
++ glamoc->drmFd = drmOpen(NULL, glamoc->busid);
++ if (glamoc->drmFd < 0)
++ ErrorF("Failed to open DRM, DRI disabled.\n");
++#endif /* USE_DRI */
++
++ card->driver = glamoc;
++
++ glamoc->is_3362 = TRUE;
++ ErrorF("Using GLAMO 3362 card\n");
++
++ return TRUE;
++}
++
++static void
++GLAMOCardFini(KdCardInfo *card)
++{
++ GLAMOCardInfo *glamoc = (GLAMOCardInfo *)card->driver;
++
++ GLAMOUnmapReg(card, glamoc);
++ glamoc->backend_funcs.cardfini(card);
++}
++
++/*
++ * Once screen->off_screen_base is set, this function
++ * allocates the remaining memory appropriately
++ */
++
++static void
++GLAMOSetOffscreen (KdScreenInfo *screen)
++{
++ GLAMOCardInfo(screen);
++#if defined(USE_DRI) && defined(GLXEXT)
++ GLAMOScreenInfo *glamos = (GLAMOScreenInfo *)screen->driver;
++ int l;
++#endif
++ int screen_size;
++ char *mmio = glamoc->reg_base;
++
++ /* check (and adjust) pitch */
++ if (mmio)
++ {
++ int byteStride = screen->fb[0].byteStride;
++ int bitStride;
++ int pixelStride;
++ int bpp = screen->fb[0].bitsPerPixel;
++
++ /*
++ * Ensure frame buffer is correctly aligned
++ */
++ if (byteStride & 0x3f)
++ {
++ byteStride = (byteStride + 0x3f) & ~0x3f;
++ bitStride = byteStride * 8;
++ pixelStride = bitStride / bpp;
++
++ screen->fb[0].byteStride = byteStride;
++ screen->fb[0].pixelStride = pixelStride;
++ }
++ }
++
++ screen_size = screen->fb[0].byteStride * screen->height;
++
++ screen->off_screen_base = screen_size;
++
++#if defined(USE_DRI) && defined(GLXEXT)
++ /* Reserve a static area for the back buffer the same size as the
++ * visible screen. XXX: This would be better initialized in glamo_dri.c
++ * when GLX is set up, but the offscreen memory manager's allocations
++ * don't last through VT switches, while the kernel's understanding of
++ * offscreen locations does.
++ */
++ glamos->frontOffset = 0;
++ glamos->frontPitch = screen->fb[0].byteStride;
++
++ if (screen->off_screen_base + screen_size <= screen->memory_size) {
++ glamos->backOffset = screen->off_screen_base;
++ glamos->backPitch = screen->fb[0].byteStride;
++ screen->off_screen_base += screen_size;
++ }
++
++ /* Reserve the depth span for Rage 128 */
++ if (!glamoc->is_3362 && screen->off_screen_base +
++ screen->fb[0].byteStride <= screen->memory_size) {
++ glamos->spanOffset = screen->off_screen_base;
++ screen->off_screen_base += screen->fb[0].byteStride;
++ }
++
++ /* Reserve the static depth buffer, which happens to be the same
++ * bitsPerPixel as the screen.
++ */
++ if (screen->off_screen_base + screen_size <= screen->memory_size) {
++ glamos->depthOffset = screen->off_screen_base;
++ glamos->depthPitch = screen->fb[0].byteStride;
++ screen->off_screen_base += screen_size;
++ }
++
++ /* Reserve approx. half of remaining offscreen memory for local
++ * textures. Round down to a whole number of texture regions.
++ */
++ glamos->textureSize = (screen->memory_size - screen->off_screen_base) / 2;
++ l = GLAMOLog2(glamos->textureSize / GLAMO_NR_TEX_REGIONS);
++ if (l < GLAMO_LOG_TEX_GRANULARITY)
++ l = GLAMO_LOG_TEX_GRANULARITY;
++ glamos->textureSize = (glamos->textureSize >> l) << l;
++ if (glamos->textureSize >= 512 * 1024) {
++ glamos->textureOffset = screen->off_screen_base;
++ screen->off_screen_base += glamos->textureSize;
++ } else {
++ /* Minimum texture size is for 2 256x256x32bpp textures */
++ glamos->textureSize = 0;
++ }
++#endif /* USE_DRI && GLXEXT */
++}
++
++static Bool
++GLAMOScreenInit(KdScreenInfo *screen)
++{
++ GLAMOScreenInfo *glamos;
++ GLAMOCardInfo(screen);
++ Bool success = FALSE;
++
++ glamos = xcalloc(sizeof(GLAMOScreenInfo), 1);
++ if (glamos == NULL)
++ return FALSE;
++
++ glamos->glamoc = glamoc;
++ glamos->screen = screen;
++ screen->driver = glamos;
++
++ if (screen->fb[0].depth == 0)
++ screen->fb[0].depth = 16;
++#ifdef KDRIVEFBDEV
++ if (glamoc->use_fbdev) {
++ success = fbdevScreenInitialize(screen,
++ &glamos->backend_priv.fbdev);
++ }
++#endif
++#ifdef KDRIVEVESA
++ if (glamoc->use_vesa) {
++ success = vesaScreenInitialize(screen,
++ &glamos->backend_priv.vesa);
++ }
++#endif
++
++ if (!success) {
++ screen->driver = NULL;
++ xfree(glamos);
++ return FALSE;
++ }
++
++ GLAMOSetOffscreen (screen);
++
++ return TRUE;
++}
++
++#ifdef RANDR
++static Bool
++GLAMORandRSetConfig (ScreenPtr pScreen,
++ Rotation randr,
++ int rate,
++ RRScreenSizePtr pSize)
++{
++ KdScreenPriv(pScreen);
++ KdScreenInfo *screen = pScreenPriv->screen;
++ GLAMOCardInfo *glamoc = screen->card->driver;
++ Bool ret;
++
++ GLAMODrawDisable (pScreen);
++ ret = glamoc->backend_funcs.randrSetConfig(pScreen, randr, rate, pSize);
++ GLAMOSetOffscreen (screen);
++ /*
++ * Set frame buffer mapping
++ */
++ (*pScreen->ModifyPixmapHeader) (fbGetScreenPixmap (pScreen),
++ pScreen->width,
++ pScreen->height,
++ screen->fb[0].depth,
++ screen->fb[0].bitsPerPixel,
++ screen->fb[0].byteStride,
++ screen->fb[0].frameBuffer);
++
++ GLAMODrawEnable (pScreen);
++ return ret;
++}
++
++static Bool
++GLAMORandRInit (ScreenPtr pScreen)
++{
++ rrScrPrivPtr pScrPriv;
++
++ pScrPriv = rrGetScrPriv(pScreen);
++ pScrPriv->rrSetConfig = GLAMORandRSetConfig;
++ return TRUE;
++}
++#endif
++
++static void
++GLAMOScreenFini(KdScreenInfo *screen)
++{
++ GLAMOScreenInfo *glamos = (GLAMOScreenInfo *)screen->driver;
++ GLAMOCardInfo *glamoc = screen->card->driver;
++
++#ifdef XV
++ GLAMOFiniVideo(screen->pScreen);
++#endif
++
++ glamoc->backend_funcs.scrfini(screen);
++ xfree(glamos);
++ screen->driver = 0;
++}
++
++Bool
++GLAMOMapReg(KdCardInfo *card, GLAMOCardInfo *glamoc)
++{
++ glamoc->reg_base = (char *)KdMapDevice(GLAMO_REG_BASE(card),
++ GLAMO_REG_SIZE(card));
++
++ if (glamoc->reg_base == NULL)
++ return FALSE;
++
++ KdSetMappedMode(GLAMO_REG_BASE(card), GLAMO_REG_SIZE(card),
++ KD_MAPPED_MODE_REGISTERS);
++
++ return TRUE;
++}
++
++void
++GLAMOUnmapReg(KdCardInfo *card, GLAMOCardInfo *glamoc)
++{
++ if (glamoc->reg_base) {
++ KdResetMappedMode(GLAMO_REG_BASE(card), GLAMO_REG_SIZE(card),
++ KD_MAPPED_MODE_REGISTERS);
++ KdUnmapDevice((void *)glamoc->reg_base, GLAMO_REG_SIZE(card));
++ glamoc->reg_base = 0;
++ }
++}
++
++static Bool
++GLAMOInitScreen(ScreenPtr pScreen)
++{
++ KdScreenPriv(pScreen);
++ GLAMOCardInfo(pScreenPriv);
++
++#ifdef XV
++ GLAMOInitVideo(pScreen);
++#endif
++ return glamoc->backend_funcs.initScreen(pScreen);
++}
++
++static Bool
++GLAMOFinishInitScreen(ScreenPtr pScreen)
++{
++ KdScreenPriv(pScreen);
++ GLAMOCardInfo(pScreenPriv);
++
++ if (!glamoc->backend_funcs.finishInitScreen(pScreen))
++ return FALSE;
++#ifdef RANDR
++ if (!GLAMORandRInit (pScreen))
++ return FALSE;
++#endif
++ return TRUE;
++}
++
++static Bool
++GLAMOCreateResources(ScreenPtr pScreen)
++{
++ KdScreenPriv(pScreen);
++ GLAMOCardInfo(pScreenPriv);
++
++ return glamoc->backend_funcs.createRes(pScreen);
++}
++
++static void
++GLAMOPreserve(KdCardInfo *card)
++{
++ GLAMOCardInfo *glamoc = card->driver;
++
++ glamoc->backend_funcs.preserve(card);
++}
++
++static void
++GLAMORestore(KdCardInfo *card)
++{
++ GLAMOCardInfo *glamoc = card->driver;
++
++ GLAMOUnmapReg(card, glamoc);
++
++ glamoc->backend_funcs.restore(card);
++}
++
++static Bool
++GLAMODPMS(ScreenPtr pScreen, int mode)
++{
++ KdScreenPriv(pScreen);
++ GLAMOCardInfo(pScreenPriv);
++
++ return glamoc->backend_funcs.dpms(pScreen, mode);
++}
++
++static Bool
++GLAMOEnable(ScreenPtr pScreen)
++{
++ KdScreenPriv(pScreen);
++ GLAMOCardInfo(pScreenPriv);
++
++ if (!glamoc->backend_funcs.enable(pScreen))
++ return FALSE;
++
++ if ((glamoc->reg_base == NULL) && !GLAMOMapReg(pScreenPriv->screen->card,
++ glamoc))
++ return FALSE;
++
++ GLAMOSetOffscreen (pScreenPriv->screen);
++
++ return TRUE;
++}
++
++static void
++GLAMODisable(ScreenPtr pScreen)
++{
++ KdScreenPriv(pScreen);
++#if defined(USE_DRI) && defined(GLXEXT)
++ GLAMOScreenInfo(pScreenPriv);
++#endif /* USE_DRI && GLXEXT */
++ GLAMOCardInfo(pScreenPriv);
++
++ GLAMOUnmapReg(pScreenPriv->card, glamoc);
++
++ glamoc->backend_funcs.disable(pScreen);
++}
++
++static void
++GLAMOGetColors(ScreenPtr pScreen, int fb, int n, xColorItem *pdefs)
++{
++ KdScreenPriv(pScreen);
++ GLAMOCardInfo(pScreenPriv);
++
++ glamoc->backend_funcs.getColors(pScreen, fb, n, pdefs);
++}
++
++static void
++GLAMOPutColors(ScreenPtr pScreen, int fb, int n, xColorItem *pdefs)
++{
++ KdScreenPriv(pScreen);
++ GLAMOCardInfo(pScreenPriv);
++
++ glamoc->backend_funcs.putColors(pScreen, fb, n, pdefs);
++}
++
++/* Compute log base 2 of val. */
++int
++GLAMOLog2(int val)
++{
++ int bits;
++
++ for (bits = 0; val != 0; val >>= 1, ++bits)
++ ;
++ return bits - 1;
++}
++
++KdCardFuncs GLAMOFuncs = {
++ GLAMOCardInit, /* cardinit */
++ GLAMOScreenInit, /* scrinit */
++ GLAMOInitScreen, /* initScreen */
++ GLAMOFinishInitScreen, /* finishInitScreen */
++ GLAMOCreateResources, /* createRes */
++ GLAMOPreserve, /* preserve */
++ GLAMOEnable, /* enable */
++ GLAMODPMS, /* dpms */
++ GLAMODisable, /* disable */
++ GLAMORestore, /* restore */
++ GLAMOScreenFini, /* scrfini */
++ GLAMOCardFini, /* cardfini */
++
++#if 0
++ GLAMOCursorInit, /* initCursor */
++ GLAMOCursorEnable, /* enableCursor */
++ GLAMOCursorDisable, /* disableCursor */
++ GLAMOCursorFini, /* finiCursor */
++ GLAMORecolorCursor, /* recolorCursor */
++#else
++ 0, /* initCursor */
++ 0, /* enableCursor */
++ 0, /* disableCursor */
++ 0, /* finiCursor */
++ 0, /* recolorCursor */
++#endif
++
++
++#if 1
++ GLAMODrawInit, /* initAccel */
++ GLAMODrawEnable, /* enableAccel */
++ GLAMODrawDisable, /* disableAccel */
++ GLAMODrawFini, /* finiAccel */
++#else
++ 0, /* initAccel */
++ 0, /* enableAccel */
++ 0, /* disableAccel */
++ 0, /* finiAccel */
++#endif
++
++ GLAMOGetColors, /* getColors */
++ GLAMOPutColors, /* putColors */
++};
+Index: xserver/hw/kdrive/glamo/glamo.h
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ xserver/hw/kdrive/glamo/glamo.h 2007-09-26 17:45:48.000000000 +0800
+@@ -0,0 +1,386 @@
++/*
++ * Copyright © 2007 OpenMoko, Inc.
++ *
++ * This driver is based on Xati,
++ * Copyright © 2003 Eric Anholt
++ *
++ * Permission to use, copy, modify, distribute, and sell this software and its
++ * documentation for any purpose is hereby granted without fee, provided that
++ * the above copyright notice appear in all copies and that both that copyright
++ * notice and this permission notice appear in supporting documentation, and
++ * that the name of the copyright holders not be used in advertising or
++ * publicity pertaining to distribution of the software without specific,
++ * written prior permission. The copyright holders make no representations
++ * about the suitability of this software for any purpose. It is provided "as
++ * is" without express or implied warranty.
++ *
++ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
++ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
++ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
++ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
++ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
++ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
++ * OF THIS SOFTWARE.
++ */
++
++#ifndef _GLAMO_H_
++#define _GLAMO_H_
++
++#ifdef HAVE_CONFIG_H
++#include <kdrive-config.h>
++#endif
++
++#ifdef KDRIVEFBDEV
++#include <fbdev.h>
++#endif
++#ifdef KDRIVEVESA
++#include <vesa.h>
++#endif
++
++#include "kxv.h"
++
++#undef XF86DRI
++#ifdef XF86DRI
++#define USE_DRI
++#include "xf86drm.h"
++#include "dri.h"
++#ifdef GLXEXT
++#include "GL/glxint.h"
++#include "GL/glxtokens.h"
++#include "glamo_dripriv.h"
++#endif
++#endif
++
++#define GLAMO_REG_BASE(c) ((c)->attr.address[0])
++#define GLAMO_REG_SIZE(c) (0x2400)
++
++#ifdef __powerpc__
++
++static __inline__ void
++MMIO_OUT16(__volatile__ void *base, const unsigned long offset,
++ const unsigned int val)
++{
++ __asm__ __volatile__(
++ "stwbrx %1,%2,%3\n\t"
++ "eieio"
++ : "=m" (*((volatile unsigned char *)base+offset))
++ : "r" (val), "b" (base), "r" (offset));
++}
++
++static __inline__ CARD32
++MMIO_IN16(__volatile__ void *base, const unsigned long offset)
++{
++ register unsigned int val;
++ __asm__ __volatile__(
++ "lwbrx %0,%1,%2\n\t"
++ "eieio"
++ : "=r" (val)
++ : "b" (base), "r" (offset),
++ "m" (*((volatile unsigned char *)base+offset)));
++ return val;
++}
++
++#else
++
++#define MMIO_OUT16(mmio, a, v) (*(VOL16 *)((mmio) + (a)) = (v))
++#define MMIO_IN16(mmio, a) (*(VOL16 *)((mmio) + (a)))
++
++#endif
++
++typedef volatile CARD8 VOL8;
++typedef volatile CARD16 VOL16;
++typedef volatile CARD32 VOL32;
++
++struct backend_funcs {
++ void (*cardfini)(KdCardInfo *);
++ void (*scrfini)(KdScreenInfo *);
++ Bool (*initScreen)(ScreenPtr);
++ Bool (*finishInitScreen)(ScreenPtr pScreen);
++ Bool (*createRes)(ScreenPtr);
++ void (*preserve)(KdCardInfo *);
++ void (*restore)(KdCardInfo *);
++ Bool (*dpms)(ScreenPtr, int);
++ Bool (*enable)(ScreenPtr);
++ void (*disable)(ScreenPtr);
++ void (*getColors)(ScreenPtr, int, int, xColorItem *);
++ void (*putColors)(ScreenPtr, int, int, xColorItem *);
++#ifdef RANDR
++ Bool (*randrSetConfig) (ScreenPtr, Rotation, int, RRScreenSizePtr);
++#endif
++};
++
++typedef struct _GLAMOCardInfo {
++ union {
++#ifdef KDRIVEFBDEV
++ FbdevPriv fbdev;
++#endif
++#ifdef KDRIVEVESA
++ VesaCardPrivRec vesa;
++#endif
++ } backend_priv;
++ struct backend_funcs backend_funcs;
++
++ char *reg_base;
++ Bool is_3362;
++ CARD32 crtc_pitch;
++ CARD32 crtc2_pitch;
++#ifdef USE_DRI
++ int drmFd;
++#endif /* USE_DRI */
++ Bool use_fbdev, use_vesa;
++} GLAMOCardInfo;
++
++#define getGLAMOCardInfo(kd) ((GLAMOCardInfo *) ((kd)->card->driver))
++#define GLAMOCardInfo(kd) GLAMOCardInfo *glamoc = getGLAMOCardInfo(kd)
++
++typedef struct _GLAMOCursor {
++ int width, height;
++ int xhot, yhot;
++
++ Bool has_cursor;
++ CursorPtr pCursor;
++ Pixel source, mask;
++ KdOffscreenArea *area;
++} GLAMOCursor;
++
++typedef struct _GLAMOPortPriv {
++ int brightness;
++ int saturation;
++ RegionRec clip;
++ CARD32 size;
++ KdOffscreenArea *off_screen;
++ DrawablePtr pDraw;
++ PixmapPtr pPixmap;
++
++ CARD32 src_offset;
++ CARD32 src_pitch;
++ CARD8 *src_addr;
++
++ int id;
++ int src_x1, src_y1, src_x2, src_y2;
++ int dst_x1, dst_y1, dst_x2, dst_y2;
++ int src_w, src_h, dst_w, dst_h;
++} GLAMOPortPrivRec, *GLAMOPortPrivPtr;
++
++typedef struct _dmaBuf {
++ int size;
++ int used;
++ void *address;
++#ifdef USE_DRI
++ drmBufPtr drmBuf;
++#endif
++} dmaBuf;
++
++typedef struct _GLAMOScreenInfo {
++ union {
++#ifdef KDRIVEFBDEV
++ FbdevScrPriv fbdev;
++#endif
++#ifdef KDRIVEVESA
++ VesaScreenPrivRec vesa;
++#endif
++ } backend_priv;
++ KaaScreenInfoRec kaa;
++
++ GLAMOCardInfo *glamoc;
++ KdScreenInfo *screen;
++
++ int scratch_offset;
++ int scratch_next;
++ KdOffscreenArea *scratch_area;
++
++ GLAMOCursor cursor;
++
++ KdVideoAdaptorPtr pAdaptor;
++ int num_texture_ports;
++
++ Bool using_dri; /* If we use the DRM for DMA. */
++
++ KdOffscreenArea *dma_space; /* For "DMA" from framebuffer. */
++ CARD16 *ring_addr; /* Beginning of ring buffer. */
++ int ring_write; /* Index of write ptr in ring. */
++ int ring_read; /* Index of read ptr in ring. */
++ int ring_len;
++
++ dmaBuf *indirectBuffer;
++ int indirectStart;
++
++#ifdef USE_DRI
++ Bool dma_started;
++
++ drmSize registerSize;
++ drmHandle registerHandle;
++ drmHandle fbHandle;
++
++ drmSize gartSize;
++ drmHandle agpMemHandle; /* Handle from drmAgpAlloc */
++ unsigned long gartOffset;
++ unsigned char *AGP; /* Map */
++ int agpMode;
++ drmSize pciSize;
++ drmHandle pciMemHandle;
++
++ /* ring buffer data */
++ unsigned long ringStart; /* Offset into AGP space */
++ drmHandle ringHandle; /* Handle from drmAddMap */
++ drmSize ringMapSize; /* Size of map */
++ int ringSize; /* Size of ring (MB) */
++ unsigned char *ring; /* Map */
++
++ unsigned long ringReadOffset; /* Offset into AGP space */
++ drmHandle ringReadPtrHandle; /* Handle from drmAddMap */
++ drmSize ringReadMapSize; /* Size of map */
++ unsigned char *ringReadPtr; /* Map */
++
++ /* vertex/indirect buffer data */
++ unsigned long bufStart; /* Offset into AGP space */
++ drmHandle bufHandle; /* Handle from drmAddMap */
++ drmSize bufMapSize; /* Size of map */
++ int bufSize; /* Size of buffers (MB) */
++ unsigned char *buf; /* Map */
++ int bufNumBufs; /* Number of buffers */
++ drmBufMapPtr buffers; /* Buffer map */
++
++ /* AGP Texture data */
++ unsigned long gartTexStart; /* Offset into AGP space */
++ drmHandle gartTexHandle; /* Handle from drmAddMap */
++ drmSize gartTexMapSize; /* Size of map */
++ int gartTexSize; /* Size of AGP tex space (MB) */
++ unsigned char *gartTex; /* Map */
++ int log2GARTTexGran;
++
++ int DMAusecTimeout; /* CCE timeout in usecs */
++
++ /* DRI screen private data */
++ int frontOffset;
++ int frontPitch;
++ int backOffset;
++ int backPitch;
++ int depthOffset;
++ int depthPitch;
++ int spanOffset;
++ int textureOffset;
++ int textureSize;
++ int log2TexGran;
++
++ int irqEnabled;
++
++ int serverContext;
++
++ DRIInfoPtr pDRIInfo;
++#ifdef GLXEXT
++ int numVisualConfigs;
++ __GLXvisualConfig *pVisualConfigs;
++ GLAMOConfigPrivPtr pVisualConfigsPriv;
++#endif /* GLXEXT */
++#endif /* USE_DRI */
++} GLAMOScreenInfo;
++
++#define getGLAMOScreenInfo(kd) ((GLAMOScreenInfo *) ((kd)->screen->driver))
++#define GLAMOScreenInfo(kd) GLAMOScreenInfo *glamos = getGLAMOScreenInfo(kd)
++
++typedef union { float f; CARD32 i; } fi_type;
++
++/* Surely there's a better way to go about this */
++static inline CARD32
++GLAMOFloatAsInt(float val)
++{
++ fi_type fi;
++
++ fi.f = val;
++ return fi.i;
++}
++
++#define GET_FLOAT_BITS(x) GLAMOFloatAsInt(x)
++
++static inline void
++MMIOSetBitMask(char *mmio, CARD32 reg, CARD16 mask, CARD16 val)
++{
++ CARD16 tmp;
++
++ val &= mask;
++
++ tmp = MMIO_IN16(mmio, reg);
++ tmp &= ~mask;
++ tmp |= val;
++
++ MMIO_OUT16(mmio, reg, tmp);
++}
++
++/* glamo.c */
++Bool
++GLAMOMapReg(KdCardInfo *card, GLAMOCardInfo *glamoc);
++
++void
++GLAMOUnmapReg(KdCardInfo *card, GLAMOCardInfo *glamoc);
++
++/* glamo_draw.c */
++void
++GLAMODrawSetup(ScreenPtr pScreen);
++
++Bool
++GLAMODrawInit(ScreenPtr pScreen);
++
++void
++GLAMODrawEnable(ScreenPtr pScreen);
++
++void
++GLAMODrawDisable(ScreenPtr pScreen);
++
++void
++GLAMODrawFini(ScreenPtr pScreen);
++
++/* glamo_dri.c */
++#ifdef USE_DRI
++Bool
++GLAMODRIScreenInit(ScreenPtr pScreen);
++
++void
++GLAMODRICloseScreen(ScreenPtr pScreen);
++
++void
++GLAMODRIDMAStart(GLAMOScreenInfo *glamos);
++
++void
++GLAMODRIDMAStop(GLAMOScreenInfo *glamos);
++
++void
++GLAMODRIDMAReset(GLAMOScreenInfo *glamos);
++
++void
++GLAMODRIDispatchIndirect(GLAMOScreenInfo *glamos, Bool discard);
++
++drmBufPtr
++GLAMODRIGetBuffer(GLAMOScreenInfo *glamos);
++
++#endif /* USE_DRI */
++
++/* glamo_cursor.c */
++Bool
++GLAMOCursorInit(ScreenPtr pScreen);
++
++void
++GLAMOCursorEnable(ScreenPtr pScreen);
++
++void
++GLAMOCursorDisable(ScreenPtr pScreen);
++
++void
++GLAMOCursorFini(ScreenPtr pScreen);
++
++void
++GLAMORecolorCursor(ScreenPtr pScreen, int ndef, xColorItem *pdef);
++
++int
++GLAMOLog2(int val);
++
++/* glamo_video.c */
++Bool
++GLAMOInitVideo(ScreenPtr pScreen);
++
++void
++GLAMOFiniVideo(ScreenPtr pScreen);
++
++extern KdCardFuncs GLAMOFuncs;
++
++#endif /* _GLAMO_H_ */
+Index: xserver/hw/kdrive/glamo/glamo_dma.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ xserver/hw/kdrive/glamo/glamo_dma.c 2007-09-26 17:45:16.000000000 +0800
+@@ -0,0 +1,410 @@
++/*
++ * Copyright © 2007 OpenMoko, Inc.
++ *
++ * This driver is based on Xati,
++ * Copyright © 2004 Eric Anholt
++ *
++ * Permission to use, copy, modify, distribute, and sell this software and its
++ * documentation for any purpose is hereby granted without fee, provided that
++ * the above copyright notice appear in all copies and that both that copyright
++ * notice and this permission notice appear in supporting documentation, and
++ * that the name of the copyright holders not be used in advertising or
++ * publicity pertaining to distribution of the software without specific,
++ * written prior permission. The copyright holders make no representations
++ * about the suitability of this software for any purpose. It is provided "as
++ * is" without express or implied warranty.
++ *
++ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
++ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
++ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
++ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
++ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
++ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
++ * OF THIS SOFTWARE.
++ */
++
++#include <sys/time.h>
++
++#include "glamo.h"
++#include "glamo-regs.h"
++#include "glamo_dma.h"
++#include "glamo_draw.h"
++
++#ifdef USE_DRI
++#include "radeon_common.h"
++#include "glamo_sarea.h"
++#endif /* USE_DRI */
++
++#define DEBUG_FIFO 1
++
++#if DEBUG_FIFO
++static void
++GLAMODebugFifo(GLAMOScreenInfo *glamos)
++{
++ GLAMOCardInfo *glamoc = glamos->glamoc;
++ char *mmio = glamoc->reg_base;
++ CARD32 offset;
++
++ ErrorF("GLAMO_REG_CQ_STATUS: 0x%04x\n",
++ MMIO_IN16(mmio, GLAMO_REG_CQ_STATUS));
++
++ offset = MMIO_IN16(mmio, GLAMO_REG_CQ_WRITE_ADDRL);
++ offset |= (MMIO_IN16(mmio, GLAMO_REG_CQ_WRITE_ADDRH) << 16) & 0x7;
++ ErrorF("GLAMO_REG_CQ_WRITE_ADDR: 0x%08x\n", (unsigned int) offset);
++
++ offset = MMIO_IN16(mmio, GLAMO_REG_CQ_READ_ADDRL);
++ offset |= (MMIO_IN16(mmio, GLAMO_REG_CQ_READ_ADDRH) << 16) & 0x7;
++ ErrorF("GLAMO_REG_CQ_READ_ADDR: 0x%08x\n", (unsigned int) offset);
++}
++#endif
++
++void
++GLAMOEngineReset(ScreenPtr pScreen, enum glamo_engine engine)
++{
++ KdScreenPriv(pScreen);
++ GLAMOCardInfo(pScreenPriv);
++ CARD32 reg;
++ CARD16 mask;
++ char *mmio = glamoc->reg_base;
++
++ if (!mmio)
++ return;
++
++ switch (engine) {
++ case GLAMO_ENGINE_ISP:
++ reg = GLAMO_REG_CLOCK_ISP;
++ mask = GLAMO_CLOCK_ISP2_RESET;
++ break;
++ case GLAMO_ENGINE_CQ:
++ reg = GLAMO_REG_CLOCK_2D;
++ mask = GLAMO_CLOCK_2D_CQ_RESET;
++ break;
++ case GLAMO_ENGINE_2D:
++ reg = GLAMO_REG_CLOCK_2D;
++ mask = GLAMO_CLOCK_2D_RESET;
++ break;
++ }
++
++ MMIOSetBitMask(mmio, reg, mask, 0xffff);
++ usleep(1000);
++ MMIOSetBitMask(mmio, reg, mask, 0);
++ usleep(1000);
++}
++
++void
++GLAMOEngineDisable(ScreenPtr pScreen, enum glamo_engine engine)
++{
++ KdScreenPriv(pScreen);
++ GLAMOCardInfo(pScreenPriv);
++ char *mmio = glamoc->reg_base;
++
++ if (!mmio)
++ return;
++
++ return;
++}
++
++void
++GLAMOEngineEnable(ScreenPtr pScreen, enum glamo_engine engine)
++{
++ KdScreenPriv(pScreen);
++ GLAMOCardInfo(pScreenPriv);
++ char *mmio = glamoc->reg_base;
++
++ if (!mmio)
++ return;
++
++ switch (engine) {
++ case GLAMO_ENGINE_ISP:
++ MMIOSetBitMask(mmio, GLAMO_REG_CLOCK_ISP,
++ GLAMO_CLOCK_ISP_EN_M2CLK |
++ GLAMO_CLOCK_ISP_EN_I1CLK,
++ 0xffff);
++ MMIOSetBitMask(mmio, GLAMO_REG_CLOCK_GEN5_2,
++ GLAMO_CLOCK_GEN52_EN_DIV_ICLK,
++ 0xffff);
++ MMIOSetBitMask(mmio, GLAMO_REG_CLOCK_GEN5_1,
++ GLAMO_CLOCK_GEN51_EN_DIV_JCLK,
++ 0xffff);
++ MMIOSetBitMask(mmio, GLAMO_REG_HOSTBUS(2),
++ GLAMO_HOSTBUS2_MMIO_EN_ISP,
++ 0xffff);
++ break;
++ case GLAMO_ENGINE_CQ:
++ MMIOSetBitMask(mmio, GLAMO_REG_CLOCK_2D,
++ GLAMO_CLOCK_2D_EN_M6CLK,
++ 0xffff);
++ MMIOSetBitMask(mmio, GLAMO_REG_HOSTBUS(2),
++ GLAMO_HOSTBUS2_MMIO_EN_CQ,
++ 0xffff);
++ MMIOSetBitMask(mmio, GLAMO_REG_CLOCK_GEN5_1,
++ GLAMO_CLOCK_GEN51_EN_DIV_MCLK,
++ 0xffff);
++ break;
++ case GLAMO_ENGINE_2D:
++ MMIOSetBitMask(mmio, GLAMO_REG_CLOCK_2D,
++ GLAMO_CLOCK_2D_EN_M7CLK |
++ GLAMO_CLOCK_2D_EN_GCLK |
++ GLAMO_CLOCK_2D_DG_M7CLK |
++ GLAMO_CLOCK_2D_DG_GCLK,
++ 0xffff);
++ MMIOSetBitMask(mmio, GLAMO_REG_HOSTBUS(2),
++ GLAMO_HOSTBUS2_MMIO_EN_2D,
++ 0xffff);
++ MMIOSetBitMask(mmio, GLAMO_REG_CLOCK_GEN5_1,
++ GLAMO_CLOCK_GEN51_EN_DIV_GCLK,
++ 0xffff);
++ break;
++ }
++}
++
++void
++GLAMOWaitIdle(GLAMOScreenInfo *glamos)
++{
++ GLAMOCardInfo *glamoc = glamos->glamoc;
++ char *mmio = glamoc->reg_base;
++ CARD16 status;
++ TIMEOUT_LOCALS;
++
++ if (glamos->indirectBuffer != NULL)
++ GLAMOFlushIndirect(glamos, 0);
++
++#ifdef USE_DRI
++ if (glamos->using_dri) {
++ int ret = 0;
++ int cmd = (glamoc->is_3362 ? DRM_RADEON_CP_IDLE :
++ DRM_R128_CCE_IDLE);
++ WHILE_NOT_TIMEOUT(2) {
++ ret = drmCommandNone(glamoc->drmFd, cmd);
++ if (ret != -EBUSY)
++ break;
++ }
++ if (TIMEDOUT()) {
++ GLAMODebugFifo(glamos);
++ FatalError("Timed out idling CCE (card hung)\n");
++ }
++ if (ret != 0)
++ ErrorF("Failed to idle DMA, returned %d\n", ret);
++ return;
++ }
++#endif
++
++ WHILE_NOT_TIMEOUT(.5) {
++ status = MMIO_IN16(mmio, GLAMO_REG_CQ_STATUS);
++ if ((status & (1 << 2)) && !(status & (1 << 8)))
++ break;
++ }
++ if (TIMEDOUT()) {
++ ErrorF("Timeout idling accelerator, resetting...\n");
++ GLAMOEngineReset(glamos->screen->pScreen, GLAMO_ENGINE_CQ);
++ GLAMODrawSetup(glamos->screen->pScreen);
++ }
++
++#if DEBUG_FIFO
++ ErrorF("Idle?\n");
++ GLAMODebugFifo(glamos);
++#endif
++}
++
++dmaBuf *
++GLAMOGetDMABuffer(GLAMOScreenInfo *glamos)
++{
++ dmaBuf *buf;
++
++ buf = (dmaBuf *)xalloc(sizeof(dmaBuf));
++ if (buf == NULL)
++ return NULL;
++
++#ifdef USE_DRI
++ if (glamos->using_dri) {
++ buf->drmBuf = GLAMODRIGetBuffer(glamos);
++ if (buf->drmBuf == NULL) {
++ xfree(buf);
++ return NULL;
++ }
++ buf->size = buf->drmBuf->total;
++ buf->used = buf->drmBuf->used;
++ buf->address = buf->drmBuf->address;
++ return buf;
++ }
++#endif /* USE_DRI */
++
++ buf->size = glamos->ring_len / 2;
++ buf->address = xalloc(buf->size);
++ if (buf->address == NULL) {
++ xfree(buf);
++ return NULL;
++ }
++ buf->used = 0;
++
++ return buf;
++}
++
++static void
++GLAMODispatchIndirectDMA(GLAMOScreenInfo *glamos)
++{
++ GLAMOCardInfo *glamoc = glamos->glamoc;
++ dmaBuf *buf = glamos->indirectBuffer;
++ char *mmio = glamoc->reg_base;
++ CARD16 *addr;
++ int count, ring_count;
++ TIMEOUT_LOCALS;
++
++ addr = (CARD16 *)((char *)buf->address + glamos->indirectStart);
++ count = (buf->used - glamos->indirectStart) / 2;
++ ring_count = glamos->ring_len / 2;
++
++ WHILE_NOT_TIMEOUT(.5) {
++ if (count <= 0)
++ break;
++
++ glamos->ring_addr[glamos->ring_write++] = *addr++;
++ if (glamos->ring_write >= ring_count)
++ glamos->ring_write = 0;
++
++ while (glamos->ring_write == glamos->ring_read)
++ {
++ glamos->ring_read =
++ MMIO_IN16(mmio, GLAMO_REG_CQ_READ_ADDRL);
++ glamos->ring_read |=
++ (MMIO_IN16(mmio, GLAMO_REG_CQ_READ_ADDRH) & 0x7) << 16;
++ }
++
++ count--;
++ }
++ if (TIMEDOUT()) {
++ ErrorF("Timeout submitting packets, resetting...\n");
++ GLAMOEngineReset(glamos->screen->pScreen, GLAMO_ENGINE_CQ);
++ GLAMODrawSetup(glamos->screen->pScreen);
++ }
++
++ MMIO_OUT16(mmio, GLAMO_REG_CQ_WRITE_ADDRH,
++ (glamos->ring_write >> 15) & 0x7);
++ MMIO_OUT16(mmio, GLAMO_REG_CQ_WRITE_ADDRL,
++ (glamos->ring_write << 1) & 0xffff);
++}
++
++void
++GLAMOFlushIndirect(GLAMOScreenInfo *glamos, Bool discard)
++{
++ dmaBuf *buf = glamos->indirectBuffer;
++
++ if ((glamos->indirectStart == buf->used) && !discard)
++ return;
++
++#if DEBUG_FIFO
++ ErrorF("Dispatching %d DWORDS\n", (buf->used - glamos->indirectStart) /
++ 4);
++#endif
++
++#ifdef USE_DRI
++ if (glamos->using_dri) {
++ buf->drmBuf->used = buf->used;
++ GLAMODRIDispatchIndirect(glamos, discard);
++ if (discard) {
++ buf->drmBuf = GLAMODRIGetBuffer(glamos);
++ buf->size = buf->drmBuf->total;
++ buf->used = buf->drmBuf->used;
++ buf->address = buf->drmBuf->address;
++ glamos->indirectStart = 0;
++ } else {
++ /* Start on a double word boundary */
++ glamos->indirectStart = buf->used = (buf->used + 7) & ~7;
++ }
++ return;
++ }
++#endif /* USE_DRI */
++
++ GLAMODispatchIndirectDMA(glamos);
++
++ buf->used = 0;
++ glamos->indirectStart = 0;
++}
++
++static Bool
++GLAMODMAInit(ScreenPtr pScreen)
++{
++ KdScreenPriv(pScreen);
++ GLAMOScreenInfo(pScreenPriv);
++ GLAMOCardInfo(pScreenPriv);
++ char *mmio = glamoc->reg_base;
++ int cq_len = 63;
++
++ glamos->ring_len = (cq_len + 1) * 1024;
++
++ glamos->dma_space = KdOffscreenAlloc(pScreen, glamos->ring_len + 4,
++ 16, TRUE, NULL, NULL);
++ if (!glamos->dma_space)
++ return FALSE;
++
++ glamos->ring_addr = (CARD16 *) (pScreenPriv->screen->memory_base +
++ glamos->dma_space->offset);
++ glamos->ring_read = 0;
++ glamos->ring_write = 0;
++
++ /* make the decoder happy? */
++ glamos->ring_addr[glamos->ring_len / 2] = 0x0;
++ glamos->ring_addr[glamos->ring_len / 2 + 1] = 0x0;
++
++ GLAMOEngineEnable(glamos->screen->pScreen, GLAMO_ENGINE_CQ);
++ GLAMOEngineReset(glamos->screen->pScreen, GLAMO_ENGINE_CQ);
++
++ MMIO_OUT16(mmio, GLAMO_REG_CQ_BASE_ADDRL,
++ glamos->dma_space->offset & 0xffff);
++ MMIO_OUT16(mmio, GLAMO_REG_CQ_BASE_ADDRH,
++ (glamos->dma_space->offset >> 16) & 0x7f);
++ MMIO_OUT16(mmio, GLAMO_REG_CQ_LEN, cq_len);
++
++ MMIO_OUT16(mmio, GLAMO_REG_CQ_WRITE_ADDRH, 0);
++ MMIO_OUT16(mmio, GLAMO_REG_CQ_WRITE_ADDRL, 0);
++ MMIO_OUT16(mmio, GLAMO_REG_CQ_READ_ADDRH, 0);
++ MMIO_OUT16(mmio, GLAMO_REG_CQ_READ_ADDRL, 0);
++ MMIO_OUT16(mmio, GLAMO_REG_CQ_CONTROL,
++ 1 << 12 |
++ 5 << 8 |
++ 8 << 4);
++
++ return TRUE;
++}
++
++void
++GLAMODMASetup(ScreenPtr pScreen)
++{
++ KdScreenPriv(pScreen);
++ GLAMOScreenInfo(pScreenPriv);
++
++#ifdef USE_DRI
++ if (glamos->using_dri)
++ GLAMODRIDMAStart(glamos);
++#endif /* USE_DRI */
++
++ if (!glamos->using_dri)
++ GLAMODMAInit(pScreen);
++
++ glamos->indirectBuffer = GLAMOGetDMABuffer(glamos);
++ if (glamos->indirectBuffer == FALSE)
++ FatalError("Failed to allocate DMA buffer.\n");
++
++ if (glamos->using_dri)
++ ErrorF("Initialized DRI DMA\n");
++ else
++ ErrorF("Initialized DMA\n");
++}
++
++void
++GLAMODMATeardown(ScreenPtr pScreen)
++{
++ KdScreenPriv(pScreen);
++ GLAMOScreenInfo(pScreenPriv);
++
++ GLAMOWaitIdle(glamos);
++
++#ifdef USE_DRI
++ if (glamos->using_dri)
++ GLAMODRIDMAStop(glamos);
++#endif /* USE_DRI */
++
++ xfree(glamos->indirectBuffer->address);
++ xfree(glamos->indirectBuffer);
++ glamos->indirectBuffer = NULL;
++}
+Index: xserver/hw/kdrive/glamo/glamo_dma.h
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ xserver/hw/kdrive/glamo/glamo_dma.h 2007-09-25 19:17:53.000000000 +0800
+@@ -0,0 +1,159 @@
++/*
++ * Copyright © 2007 OpenMoko, Inc.
++ *
++ * This driver is based on Xati,
++ * Copyright © 2004 Eric Anholt
++ *
++ * Permission to use, copy, modify, distribute, and sell this software and its
++ * documentation for any purpose is hereby granted without fee, provided that
++ * the above copyright notice appear in all copies and that both that copyright
++ * notice and this permission notice appear in supporting documentation, and
++ * that the name of the copyright holders not be used in advertising or
++ * publicity pertaining to distribution of the software without specific,
++ * written prior permission. The copyright holders make no representations
++ * about the suitability of this software for any purpose. It is provided "as
++ * is" without express or implied warranty.
++ *
++ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
++ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
++ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
++ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
++ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
++ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
++ * OF THIS SOFTWARE.
++ */
++
++#ifndef _GLAMO_DMA_H_
++#define _GLAMO_DMA_H_
++
++#define CCE_DEBUG 1
++
++#if !CCE_DEBUG
++#define DMA_PACKET0(reg, count) \
++ (reg)
++#else
++#define DMA_PACKET0(reg, count) \
++ (__packet0count = (count), __reg = (reg), \
++ (reg))
++#endif
++#define DMA_PACKET1(reg1, reg2) \
++ (GLAMO_CCE_PACKET1 | \
++ (((reg2) >> 2) << GLAMO_CCE_PACKET1_REG_2_SHIFT) | ((reg1) >> 2))
++#define DMA_PACKET3(type, count) \
++ ((type) | (((count) - 1) << 16))
++
++#if !CCE_DEBUG
++
++#define RING_LOCALS CARD16 *__head; int __count
++#define BEGIN_DMA(n) \
++do { \
++ if ((glamos->indirectBuffer->used + 2 * (n)) > \
++ glamos->indirectBuffer->size) { \
++ GLAMOFlushIndirect(glamos, 1); \
++ } \
++ __head = (CARD16 *)((char *)glamos->indirectBuffer->address + \
++ glamos->indirectBuffer->used); \
++ __count = 0; \
++} while (0)
++#define END_DMA() do { \
++ glamos->indirectBuffer->used += __count * 2; \
++} while (0)
++
++#else
++
++#define RING_LOCALS \
++ CARD16 *__head; int __count, __total, __reg, __packet0count
++#define BEGIN_DMA(n) \
++do { \
++ if ((glamos->indirectBuffer->used + 2 * (n)) > \
++ glamos->indirectBuffer->size) { \
++ GLAMOFlushIndirect(glamos, 1); \
++ } \
++ __head = (CARD16 *)((char *)glamos->indirectBuffer->address + \
++ glamos->indirectBuffer->used); \
++ __count = 0; \
++ __total = n; \
++ __reg = 0; \
++ __packet0count = 0; \
++} while (0)
++#define END_DMA() do { \
++ if (__count != __total) \
++ FatalError("count != total (%d vs %d) at %s:%d\n", \
++ __count, __total, __FILE__, __LINE__); \
++ glamos->indirectBuffer->used += __count * 2; \
++} while (0)
++
++#endif
++
++#define OUT_RING(val) do { \
++ __head[__count++] = (val); \
++} while (0)
++
++#define OUT_RING_REG(reg, val) do { \
++ if (__reg != reg) \
++ FatalError("unexpected reg (0x%x vs 0x%x) at %s:%d\n", \
++ reg, __reg, __FILE__, __LINE__); \
++ if (__packet0count-- <= 0) \
++ FatalError("overrun of packet0 at %s:%d\n", \
++ __FILE__, __LINE__); \
++ __head[__count++] = (val); \
++ __reg += 4; \
++} while (0)
++
++#define OUT_RING_F(x) OUT_RING(GET_FLOAT_BITS(x))
++
++#define OUT_REG(reg, val) \
++do { \
++ OUT_RING(DMA_PACKET0(reg, 1)); \
++ OUT_RING(val); \
++} while (0)
++
++#define TIMEOUT_LOCALS struct timeval _target, _curtime
++
++static inline Bool
++tv_le(struct timeval *tv1, struct timeval *tv2)
++{
++ if (tv1->tv_sec < tv2->tv_sec ||
++ (tv1->tv_sec == tv2->tv_sec && tv1->tv_usec < tv2->tv_usec))
++ return TRUE;
++ else
++ return FALSE;
++}
++
++#define WHILE_NOT_TIMEOUT(_timeout) \
++ gettimeofday(&_target, NULL); \
++ _target.tv_usec += ((_timeout) * 1000000); \
++ _target.tv_sec += _target.tv_usec / 1000000; \
++ _target.tv_usec = _target.tv_usec % 1000000; \
++ while (gettimeofday(&_curtime, NULL), tv_le(&_curtime, &_target))
++
++#define TIMEDOUT() (!tv_le(&_curtime, &_target))
++
++dmaBuf *
++GLAMOGetDMABuffer(GLAMOScreenInfo *glamos);
++
++void
++GLAMOFlushIndirect(GLAMOScreenInfo *glamos, Bool discard);
++
++void
++GLAMODMASetup(ScreenPtr pScreen);
++
++void
++GLAMODMATeardown(ScreenPtr pScreen);
++
++enum glamo_engine {
++ GLAMO_ENGINE_ISP,
++ GLAMO_ENGINE_CQ,
++ GLAMO_ENGINE_2D,
++};
++
++void
++GLAMOEngineEnable(ScreenPtr pScreen, enum glamo_engine engine);
++
++void
++GLAMOEngineDisable(ScreenPtr pScreen, enum glamo_engine engine);
++
++void
++GLAMOEngineReset(ScreenPtr pScreen, enum glamo_engine engine);
++
++#endif /* _GLAMO_DMA_H_ */
+Index: xserver/hw/kdrive/glamo/glamo_draw.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ xserver/hw/kdrive/glamo/glamo_draw.c 2007-09-26 17:46:30.000000000 +0800
+@@ -0,0 +1,522 @@
++/*
++ * Copyright © 2007 OpenMoko, Inc.
++ *
++ * This driver is based on Xati,
++ * Copyright © 2003 Eric Anholt
++ *
++ * Permission to use, copy, modify, distribute, and sell this software and its
++ * documentation for any purpose is hereby granted without fee, provided that
++ * the above copyright notice appear in all copies and that both that copyright
++ * notice and this permission notice appear in supporting documentation, and
++ * that the name of the copyright holders not be used in advertising or
++ * publicity pertaining to distribution of the software without specific,
++ * written prior permission. The copyright holders make no representations
++ * about the suitability of this software for any purpose. It is provided "as
++ * is" without express or implied warranty.
++ *
++ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
++ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
++ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
++ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
++ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
++ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
++ * OF THIS SOFTWARE.
++ */
++
++#ifdef HAVE_CONFIG_H
++#include <kdrive-config.h>
++#endif
++#include "glamo.h"
++#include "glamo-regs.h"
++#include "glamo_dma.h"
++#include "glamo_draw.h"
++#include "kaa.h"
++
++static const CARD8 GLAMOSolidRop[16] = {
++ /* GXclear */ 0x00, /* 0 */
++ /* GXand */ 0xa0, /* src AND dst */
++ /* GXandReverse */ 0x50, /* src AND NOT dst */
++ /* GXcopy */ 0xf0, /* src */
++ /* GXandInverted*/ 0x0a, /* NOT src AND dst */
++ /* GXnoop */ 0xaa, /* dst */
++ /* GXxor */ 0x5a, /* src XOR dst */
++ /* GXor */ 0xfa, /* src OR dst */
++ /* GXnor */ 0x05, /* NOT src AND NOT dst */
++ /* GXequiv */ 0xa5, /* NOT src XOR dst */
++ /* GXinvert */ 0x55, /* NOT dst */
++ /* GXorReverse */ 0xf5, /* src OR NOT dst */
++ /* GXcopyInverted*/ 0x0f, /* NOT src */
++ /* GXorInverted */ 0xaf, /* NOT src OR dst */
++ /* GXnand */ 0x5f, /* NOT src OR NOT dst */
++ /* GXset */ 0xff, /* 1 */
++};
++
++static const CARD8 GLAMOBltRop[16] = {
++ /* GXclear */ 0x00, /* 0 */
++ /* GXand */ 0x88, /* src AND dst */
++ /* GXandReverse */ 0x44, /* src AND NOT dst */
++ /* GXcopy */ 0xcc, /* src */
++ /* GXandInverted*/ 0x22, /* NOT src AND dst */
++ /* GXnoop */ 0xaa, /* dst */
++ /* GXxor */ 0x66, /* src XOR dst */
++ /* GXor */ 0xee, /* src OR dst */
++ /* GXnor */ 0x11, /* NOT src AND NOT dst */
++ /* GXequiv */ 0x99, /* NOT src XOR dst */
++ /* GXinvert */ 0x55, /* NOT dst */
++ /* GXorReverse */ 0xdd, /* src OR NOT dst */
++ /* GXcopyInverted*/ 0x33, /* NOT src */
++ /* GXorInverted */ 0xbb, /* NOT src OR dst */
++ /* GXnand */ 0x77, /* NOT src OR NOT dst */
++ /* GXset */ 0xff, /* 1 */
++};
++
++GLAMOScreenInfo *accel_glamos;
++CARD32 settings, color, src_pitch_offset, dst_pitch_offset;
++
++int sample_count;
++float sample_offsets_x[255];
++float sample_offsets_y[255];
++
++void
++GLAMODrawSetup(ScreenPtr pScreen)
++{
++ GLAMOEngineEnable(pScreen, GLAMO_ENGINE_2D);
++ GLAMOEngineReset(pScreen, GLAMO_ENGINE_2D);
++}
++
++static void
++GLAMOWaitMarker(ScreenPtr pScreen, int marker)
++{
++ KdScreenPriv(pScreen);
++ GLAMOScreenInfo(pScreenPriv);
++
++ ENTER_DRAW(0);
++ GLAMOWaitIdle(glamos);
++ LEAVE_DRAW(0);
++}
++
++#if GLAMO_TRACE_DRAW
++void
++GLAMOEnterDraw (PixmapPtr pPix, const char *function)
++{
++ if (pPix != NULL) {
++ KdScreenPriv(pPix->drawable.pScreen);
++ CARD32 offset;
++
++ offset = ((CARD8 *)pPix->devPrivate.ptr -
++ pScreenPriv->screen->memory_base);
++
++ ErrorF ("Enter %s 0x%x (%dx%dx%d/%d)\n", function, (unsigned int) offset,
++ pPix->drawable.width, pPix->drawable.height, pPix->drawable.depth,
++ (unsigned int) pPix->drawable.bitsPerPixel);
++ } else
++ ErrorF ("Enter %s\n", function);
++}
++
++void
++GLAMOLeaveDraw (PixmapPtr pPix, const char *function)
++{
++ if (pPix != NULL) {
++ KdScreenPriv(pPix->drawable.pScreen);
++ CARD32 offset;
++
++ offset = ((CARD8 *)pPix->devPrivate.ptr -
++ pScreenPriv->screen->memory_base);
++
++ ErrorF ("Leave %s 0x%x\n", function, (unsigned int) offset);
++ } else
++ ErrorF ("Leave %s\n", function);
++}
++#endif
++
++static Bool
++GLAMOPrepareSolid(PixmapPtr pPix, int alu, Pixel pm, Pixel fg)
++{
++ KdScreenPriv(pPix->drawable.pScreen);
++ GLAMOScreenInfo(pScreenPriv);
++ CARD32 offset, pitch;
++ FbBits mask;
++ RING_LOCALS;
++
++ if (pPix->drawable.bitsPerPixel != 16)
++ GLAMO_FALLBACK(("Only 16bpp is supported\n"));
++
++ mask = FbFullMask(16);
++ if ((pm & mask) != mask)
++ GLAMO_FALLBACK(("Can't do planemask 0x%08x\n", (unsigned int) pm));
++
++ accel_glamos = glamos;
++
++ settings = GLAMOSolidRop[alu] << 8;
++ offset = ((CARD8 *) pPix->devPrivate.ptr -
++ pScreenPriv->screen->memory_base);
++ pitch = pPix->devKind;
++
++ ENTER_DRAW(pPix);
++
++ BEGIN_DMA(12);
++ OUT_REG(GLAMO_REG_2D_DST_ADDRL, offset & 0xffff);
++ OUT_REG(GLAMO_REG_2D_DST_ADDRH, (offset >> 16) & 0x7f);
++ OUT_REG(GLAMO_REG_2D_DST_PITCH, pitch);
++ OUT_REG(GLAMO_REG_2D_DST_HEIGHT, pPix->drawable.height);
++ OUT_REG(GLAMO_REG_2D_PAT_FG, fg);
++ OUT_REG(GLAMO_REG_2D_COMMAND2, settings);
++ END_DMA();
++
++ LEAVE_DRAW(pPix);
++
++ return TRUE;
++}
++
++static void
++GLAMOSolid(int x1, int y1, int x2, int y2)
++{
++ ENTER_DRAW(0);
++ GLAMOScreenInfo *glamos = accel_glamos;
++ RING_LOCALS;
++
++ BEGIN_DMA(14);
++ OUT_REG(GLAMO_REG_2D_DST_X, x1);
++ OUT_REG(GLAMO_REG_2D_DST_Y, y1);
++ OUT_REG(GLAMO_REG_2D_RECT_WIDTH, x2 - x1);
++ OUT_REG(GLAMO_REG_2D_RECT_HEIGHT, y2 - y1);
++ OUT_REG(GLAMO_REG_2D_COMMAND3, 0);
++ OUT_REG(GLAMO_REG_2D_ID1, 0);
++ OUT_REG(GLAMO_REG_2D_ID2, 0);
++ END_DMA();
++ LEAVE_DRAW(0);
++}
++
++static void
++GLAMODoneSolid(void)
++{
++ ENTER_DRAW(0);
++ LEAVE_DRAW(0);
++}
++
++static Bool
++GLAMOPrepareCopy(PixmapPtr pSrc, PixmapPtr pDst, int dx, int dy, int alu, Pixel pm)
++{
++ KdScreenPriv(pDst->drawable.pScreen);
++ GLAMOScreenInfo(pScreenPriv);
++ CARD32 src_offset, src_pitch;
++ CARD32 dst_offset, dst_pitch;
++ FbBits mask;
++ RING_LOCALS;
++
++ if (pSrc->drawable.bitsPerPixel != 16 ||
++ pDst->drawable.bitsPerPixel != 16)
++ GLAMO_FALLBACK(("Only 16bpp is supported"));
++
++ mask = FbFullMask(16);
++ if ((pm & mask) != mask)
++ GLAMO_FALLBACK(("Can't do planemask 0x%08x", (unsigned int) pm));
++
++ accel_glamos = glamos;
++
++ src_offset = ((CARD8 *) pSrc->devPrivate.ptr -
++ pScreenPriv->screen->memory_base);
++ src_pitch = pSrc->devKind;
++
++ dst_offset = ((CARD8 *) pDst->devPrivate.ptr -
++ pScreenPriv->screen->memory_base);
++ dst_pitch = pDst->devKind;
++
++ settings = GLAMOBltRop[alu] << 8;
++
++ ENTER_DRAW (pDst);
++
++ BEGIN_DMA(16);
++
++ OUT_REG(GLAMO_REG_2D_SRC_ADDRL, src_offset & 0xffff);
++ OUT_REG(GLAMO_REG_2D_SRC_ADDRH, (src_offset >> 16) & 0x7f);
++ OUT_REG(GLAMO_REG_2D_SRC_PITCH, src_pitch);
++
++ OUT_REG(GLAMO_REG_2D_DST_ADDRL, dst_offset & 0xffff);
++ OUT_REG(GLAMO_REG_2D_DST_ADDRH, (dst_offset >> 16) & 0x7f);
++ OUT_REG(GLAMO_REG_2D_DST_PITCH, dst_pitch);
++ OUT_REG(GLAMO_REG_2D_DST_HEIGHT, pDst->drawable.height);
++
++ OUT_REG(GLAMO_REG_2D_COMMAND2, settings);
++
++ END_DMA();
++
++ LEAVE_DRAW(pDst);
++
++ return TRUE;
++}
++
++static void
++GLAMOCopy(int srcX, int srcY, int dstX, int dstY, int w, int h)
++{
++ GLAMOScreenInfo *glamos = accel_glamos;
++ RING_LOCALS;
++
++ BEGIN_DMA(18);
++ OUT_REG(GLAMO_REG_2D_SRC_X, srcX);
++ OUT_REG(GLAMO_REG_2D_SRC_Y, srcY);
++ OUT_REG(GLAMO_REG_2D_DST_X, dstX);
++ OUT_REG(GLAMO_REG_2D_DST_Y, dstY);
++ OUT_REG(GLAMO_REG_2D_RECT_WIDTH, w);
++ OUT_REG(GLAMO_REG_2D_RECT_HEIGHT, h);
++ OUT_REG(GLAMO_REG_2D_COMMAND3, 0);
++ OUT_REG(GLAMO_REG_2D_ID1, 0);
++ OUT_REG(GLAMO_REG_2D_ID2, 0);
++ END_DMA();
++}
++
++static void
++GLAMODoneCopy(void)
++{
++ ENTER_DRAW(0);
++ LEAVE_DRAW(0);
++}
++
++static Bool
++GLAMOUploadToScreen(PixmapPtr pDst, char *src, int src_pitch)
++{
++ int width, height, bpp, i;
++ CARD8 *dst_offset;
++ int dst_pitch;
++
++ dst_offset = (CARD8 *)pDst->devPrivate.ptr;
++ dst_pitch = pDst->devKind;
++ width = pDst->drawable.width;
++ height = pDst->drawable.height;
++ bpp = pDst->drawable.bitsPerPixel;
++ bpp /= 8;
++
++ for (i = 0; i < height; i++)
++ {
++ memcpy(dst_offset, src, width * bpp);
++
++ dst_offset += dst_pitch;
++ src += src_pitch;
++ }
++
++ ErrorF("hostdata upload %d,%d %dbpp\n", width, height, bpp);
++
++ return TRUE;
++}
++
++
++#if 0
++static Bool
++GLAMOUploadToScratch(PixmapPtr pSrc, PixmapPtr pDst)
++{
++ KdScreenPriv(pSrc->drawable.pScreen);
++ GLAMOCardInfo(pScreenPriv);
++ GLAMOScreenInfo(pScreenPriv);
++ int dst_pitch, src_pitch, w, i, size, bytes;
++ unsigned char *dst, *src;
++ RING_LOCALS;
++
++ ENTER_DRAW(pSrc);
++ /* Align width to log 2, useful for R128 composite. This should be a
++ * KAA flag we check for (and supported in kaa.c in general) since many
++ * older bits of hardware are going to want POT pitches.
++ */
++ w = pSrc->drawable.width;
++ if (glamos->kaa.flags & KAA_OFFSCREEN_ALIGN_POT)
++ w = 1 << (GLAMOLog2(w - 1) + 1);
++ dst_pitch = (w * pSrc->drawable.bitsPerPixel / 8 +
++ glamos->kaa.pitchAlign - 1) & ~(glamos->kaa.pitchAlign - 1);
++
++ size = dst_pitch * pSrc->drawable.height;
++ if (size > glamos->scratch_area->size)
++ GLAMO_FALLBACK(("Pixmap too large for scratch (%d,%d)\n",
++ pSrc->drawable.width, pSrc->drawable.height));
++
++ glamos->scratch_next = (glamos->scratch_next + glamos->kaa.offsetAlign - 1) &
++ ~(glamos->kaa.offsetAlign - 1);
++ if (glamos->scratch_next + size > glamos->scratch_area->offset +
++ glamos->scratch_area->size) {
++ /* Only sync when we've used all of the scratch area. */
++ kaaWaitSync(pSrc->drawable.pScreen);
++ glamos->scratch_next = glamos->scratch_area->offset;
++ }
++ memcpy(pDst, pSrc, sizeof(*pDst));
++ pDst->devKind = dst_pitch;
++ pDst->devPrivate.ptr = pScreenPriv->screen->memory_base +
++ glamos->scratch_next;
++ glamos->scratch_next += size;
++
++ src = pSrc->devPrivate.ptr;
++ src_pitch = pSrc->devKind;
++ dst = pDst->devPrivate.ptr;
++ bytes = src_pitch < dst_pitch ? src_pitch : dst_pitch;
++
++ i = pSrc->drawable.height;
++ while (i--) {
++ memcpy(dst, src, bytes);
++ dst += dst_pitch;
++ src += src_pitch;
++ }
++
++ /* Flush the pixel cache */
++ if (glamoc->is_3362) {
++ BEGIN_DMA(4);
++ OUT_REG(RADEON_REG_RB3D_DSTCACHE_CTLSTAT,
++ RADEON_RB3D_DC_FLUSH_ALL);
++ OUT_REG(GLAMO_REG_WAIT_UNTIL, RADEON_WAIT_HOST_IDLECLEAN);
++ END_DMA();
++ } else {
++ BEGIN_DMA(2);
++ OUT_REG(R128_REG_PC_GUI_CTLSTAT, R128_PC_FLUSH_ALL);
++ END_DMA();
++ }
++
++ LEAVE_DRAW(pSrc);
++ return TRUE;
++}
++#endif
++
++static void
++GLAMOBlockHandler(pointer blockData, OSTimePtr timeout, pointer readmask)
++{
++ ScreenPtr pScreen = (ScreenPtr) blockData;
++ KdScreenPriv(pScreen);
++ GLAMOScreenInfo(pScreenPriv);
++
++ /* When the server is going to sleep, make sure that all DMA data has
++ * been flushed.
++ */
++ if (glamos->indirectBuffer)
++ GLAMOFlushIndirect(glamos, 1);
++}
++
++static void
++GLAMOWakeupHandler(pointer blockData, int result, pointer readmask)
++{
++}
++
++Bool
++GLAMODrawInit(ScreenPtr pScreen)
++{
++ KdScreenPriv(pScreen);
++ GLAMOScreenInfo(pScreenPriv);
++
++ ErrorF("Screen: %d/%d depth/bpp\n", pScreenPriv->screen->fb[0].depth,
++ pScreenPriv->screen->fb[0].bitsPerPixel);
++
++ RegisterBlockAndWakeupHandlers(GLAMOBlockHandler, GLAMOWakeupHandler,
++ pScreen);
++
++ glamos->using_dri = FALSE;
++#ifdef USE_DRI
++ glamos->using_dri = GLAMODRIScreenInit(pScreen);
++#endif /* USE_DRI */
++
++ memset(&glamos->kaa, 0, sizeof(KaaScreenInfoRec));
++ glamos->kaa.waitMarker = GLAMOWaitMarker;
++ glamos->kaa.PrepareSolid = GLAMOPrepareSolid;
++ glamos->kaa.Solid = GLAMOSolid;
++ glamos->kaa.DoneSolid = GLAMODoneSolid;
++ glamos->kaa.PrepareCopy = GLAMOPrepareCopy;
++ glamos->kaa.Copy = GLAMOCopy;
++ glamos->kaa.DoneCopy = GLAMODoneCopy;
++ /* Other acceleration will be hooked in in DrawEnable depending on
++ * what type of DMA gets initialized.
++ */
++
++ glamos->kaa.flags = KAA_OFFSCREEN_PIXMAPS;
++ glamos->kaa.offsetAlign = 2;
++ glamos->kaa.pitchAlign = 2;
++
++ kaaInitTrapOffsets(8, sample_offsets_x, sample_offsets_y, 0.0, 0.0);
++ sample_count = (1 << 8) - 1;
++
++ if (!kaaDrawInit(pScreen, &glamos->kaa))
++ return FALSE;
++
++ return TRUE;
++}
++
++#if 0
++static void
++GLAMOScratchSave(ScreenPtr pScreen, KdOffscreenArea *area)
++{
++ KdScreenPriv(pScreen);
++ GLAMOScreenInfo(pScreenPriv);
++
++ glamos->scratch_area = NULL;
++}
++#endif
++
++void
++GLAMODrawEnable(ScreenPtr pScreen)
++{
++ KdScreenPriv(pScreen);
++ GLAMOScreenInfo(pScreenPriv);
++
++ GLAMODMASetup(pScreen);
++ GLAMODrawSetup(pScreen);
++
++ glamos->scratch_area = NULL;
++ glamos->kaa.PrepareBlend = NULL;
++ glamos->kaa.Blend = NULL;
++ glamos->kaa.DoneBlend = NULL;
++ glamos->kaa.CheckComposite = NULL;
++ glamos->kaa.PrepareComposite = NULL;
++ glamos->kaa.Composite = NULL;
++ glamos->kaa.DoneComposite = NULL;
++ glamos->kaa.UploadToScreen = NULL;
++ glamos->kaa.UploadToScratch = NULL;
++
++#ifdef USE_DRI
++ if (glamos->using_dri) {
++ if (!glamoc->is_3362) {
++ /*glamos->kaa.PrepareTrapezoids = R128PrepareTrapezoids;
++ glamos->kaa.Trapezoids = R128Trapezoids;
++ glamos->kaa.DoneTrapezoids = R128DoneTrapezoids;*/
++ } else if (glamoc->is_r100 || glamoc->is_r200) {
++ glamos->kaa.PrepareTrapezoids = RadeonPrepareTrapezoids;
++ glamos->kaa.Trapezoids = RadeonTrapezoids;
++ glamos->kaa.DoneTrapezoids = RadeonDoneTrapezoids;
++ }
++ }
++#endif /* USE_DRI */
++
++ glamos->kaa.UploadToScreen = GLAMOUploadToScreen;
++
++ /* Reserve a scratch area. It'll be used for storing glyph data during
++ * Composite operations, because glyphs aren't in real pixmaps and thus
++ * can't be migrated.
++ */
++#if 0
++ glamos->scratch_area = KdOffscreenAlloc(pScreen, 131072,
++ glamos->kaa.offsetAlign, TRUE, GLAMOScratchSave, glamos);
++ if (glamos->scratch_area != NULL) {
++ glamos->scratch_next = glamos->scratch_area->offset;
++ glamos->kaa.UploadToScratch = GLAMOUploadToScratch;
++ }
++#endif
++
++ kaaMarkSync(pScreen);
++}
++
++void
++GLAMODrawDisable(ScreenPtr pScreen)
++{
++ kaaWaitSync(pScreen);
++ GLAMODMATeardown(pScreen);
++}
++
++void
++GLAMODrawFini(ScreenPtr pScreen)
++{
++#ifdef USE_DRI
++ KdScreenPriv(pScreen);
++ GLAMOScreenInfo(pScreenPriv);
++ if (glamos->using_dri) {
++ GLAMODRICloseScreen(pScreen);
++ glamos->using_dri = FALSE;
++ }
++#endif /* USE_DRI */
++
++ RemoveBlockAndWakeupHandlers(GLAMOBlockHandler, GLAMOWakeupHandler,
++ pScreen);
++
++ kaaDrawFini(pScreen);
++}
++
+Index: xserver/hw/kdrive/glamo/glamo_draw.h
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ xserver/hw/kdrive/glamo/glamo_draw.h 2007-09-25 19:02:01.000000000 +0800
+@@ -0,0 +1,59 @@
++/*
++ * Copyright © 2007 OpenMoko, Inc.
++ *
++ * This driver is based on Xati,
++ * Copyright © 2004 Eric Anholt
++ *
++ * Permission to use, copy, modify, distribute, and sell this software and its
++ * documentation for any purpose is hereby granted without fee, provided that
++ * the above copyright notice appear in all copies and that both that copyright
++ * notice and this permission notice appear in supporting documentation, and
++ * that the name of the copyright holders not be used in advertising or
++ * publicity pertaining to distribution of the software without specific,
++ * written prior permission. The copyright holders make no representations
++ * about the suitability of this software for any purpose. It is provided "as
++ * is" without express or implied warranty.
++ *
++ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
++ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
++ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
++ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
++ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
++ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
++ * OF THIS SOFTWARE.
++ */
++
++#ifndef _GLAMO_DRAW_H_
++#define _GLAMO_DRAW_H_
++
++void GLAMOWaitIdle(GLAMOScreenInfo *glamos);
++
++#define GLAMO_TRACE_FALL 1
++#define GLAMO_TRACE_DRAW 1
++
++#if GLAMO_TRACE_FALL
++#define GLAMO_FALLBACK(x) \
++do { \
++ ErrorF("%s: ", __FUNCTION__); \
++ ErrorF x; \
++ return FALSE; \
++} while (0)
++#else
++#define GLAMO_FALLBACK(x) return FALSE
++#endif
++
++#if GLAMO_TRACE_DRAW
++#define ENTER_DRAW(pix) GLAMOEnterDraw(pix, __FUNCTION__)
++#define LEAVE_DRAW(pix) GLAMOLeaveDraw(pix, __FUNCTION__)
++
++void
++GLAMOEnterDraw (PixmapPtr pPixmap, const char *function);
++
++void
++GLAMOLeaveDraw (PixmapPtr pPixmap, const char *function);
++#else /* GLAMO_TRACE */
++#define ENTER_DRAW(pix)
++#define LEAVE_DRAW(pix)
++#endif /* !GLAMO_TRACE */
++
++#endif /* _GLAMO_DRAW_H_ */
+Index: xserver/hw/kdrive/glamo/glamo_stub.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ xserver/hw/kdrive/glamo/glamo_stub.c 2007-09-26 17:45:27.000000000 +0800
+@@ -0,0 +1,84 @@
++/*
++ * Copyright © 2007 OpenMoko, Inc.
++ *
++ * This driver is based on Xati,
++ * Copyright © 2003 Eric Anholt
++ *
++ * Permission to use, copy, modify, distribute, and sell this software and its
++ * documentation for any purpose is hereby granted without fee, provided that
++ * the above copyright notice appear in all copies and that both that copyright
++ * notice and this permission notice appear in supporting documentation, and
++ * that the name of the copyright holders not be used in advertising or
++ * publicity pertaining to distribution of the software without specific,
++ * written prior permission. The copyright holders make no representations
++ * about the suitability of this software for any purpose. It is provided "as
++ * is" without express or implied warranty.
++ *
++ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
++ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
++ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
++ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
++ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
++ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
++ * OF THIS SOFTWARE.
++ */
++
++#ifdef HAVE_CONFIG_H
++#include <kdrive-config.h>
++#endif
++#include "glamo.h"
++#include "klinux.h"
++
++void
++InitCard(char *name)
++{
++ KdCardAttr attr;
++
++ attr.io = 0;
++ attr.address[0] = 0x8000000;
++ attr.naddr = 1;
++ KdCardInfoAdd(&GLAMOFuncs, &attr, 0);
++}
++
++void
++InitOutput(ScreenInfo *pScreenInfo, int argc, char **argv)
++{
++ KdInitOutput(pScreenInfo, argc, argv);
++}
++
++void
++InitInput(int argc, char **argv)
++{
++ KdKeyboardInfo *ki;
++
++ KdAddKeyboardDriver(&LinuxKeyboardDriver);
++ KdAddPointerDriver(&LinuxMouseDriver);
++#ifdef TSLIB
++ KdAddPointerDriver(&TsDriver);
++#endif
++
++ ki = KdParseKeyboard("keybd");
++ KdAddKeyboard(ki);
++}
++
++void
++ddxUseMsg (void)
++{
++ KdUseMsg();
++#ifdef KDRIVEVESA
++ vesaUseMsg();
++#endif
++}
++
++int
++ddxProcessArgument(int argc, char **argv, int i)
++{
++ int ret;
++
++#ifdef KDRIVEVESA
++ if (!(ret = vesaProcessArgument (argc, argv, i)))
++#endif
++ ret = KdProcessArgument(argc, argv, i);
++
++ return ret;
++}
+Index: xserver/hw/kdrive/glamo/glamo_video.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ xserver/hw/kdrive/glamo/glamo_video.c 2007-09-26 17:47:55.000000000 +0800
+@@ -0,0 +1,798 @@
++/*
++ * Copyright © 2007 OpenMoko, Inc.
++ *
++ * This driver is based on Xati,
++ * Copyright © 2004 Keith Packard
++ * Copyright © 2005 Eric Anholt
++ *
++ * Permission to use, copy, modify, distribute, and sell this software and its
++ * documentation for any purpose is hereby granted without fee, provided that
++ * the above copyright notice appear in all copies and that both that copyright
++ * notice and this permission notice appear in supporting documentation, and
++ * that the name of the copyright holders not be used in advertising or
++ * publicity pertaining to distribution of the software without specific,
++ * written prior permission. The copyright holders make no representations
++ * about the suitability of this software for any purpose. It is provided "as
++ * is" without express or implied warranty.
++ *
++ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
++ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
++ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
++ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
++ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
++ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
++ * OF THIS SOFTWARE.
++ */
++
++#ifdef HAVE_CONFIG_H
++#include <kdrive-config.h>
++#endif
++#include "glamo.h"
++#include "glamo_dma.h"
++#include "glamo_draw.h"
++#include "glamo-regs.h"
++#include "kaa.h"
++
++#include <X11/extensions/Xv.h>
++#include "fourcc.h"
++
++#define MAKE_ATOM(a) MakeAtom(a, sizeof(a) - 1, TRUE)
++
++static Atom xvBrightness, xvSaturation;
++
++#define IMAGE_MAX_WIDTH 2048
++#define IMAGE_MAX_HEIGHT 2048
++
++static void
++GLAMOStopVideo(KdScreenInfo *screen, pointer data, Bool exit)
++{
++ ScreenPtr pScreen = screen->pScreen;
++ GLAMOPortPrivPtr pPortPriv = (GLAMOPortPrivPtr)data;
++
++ REGION_EMPTY(screen->pScreen, &pPortPriv->clip);
++
++ if (pPortPriv->off_screen) {
++ KdOffscreenFree (pScreen, pPortPriv->off_screen);
++ pPortPriv->off_screen = 0;
++ }
++}
++
++static int
++GLAMOSetPortAttribute(KdScreenInfo *screen, Atom attribute, int value,
++ pointer data)
++{
++ return BadMatch;
++}
++
++static int
++GLAMOGetPortAttribute(KdScreenInfo *screen, Atom attribute, int *value,
++ pointer data)
++{
++ return BadMatch;
++}
++
++static void
++GLAMOQueryBestSize(KdScreenInfo *screen, Bool motion, short vid_w, short vid_h,
++ short drw_w, short drw_h, unsigned int *p_w, unsigned int *p_h,
++ pointer data)
++{
++ *p_w = drw_w;
++ *p_h = drw_h;
++}
++
++/* GLAMOClipVideo -
++
++ Takes the dst box in standard X BoxRec form (top and left
++ edges inclusive, bottom and right exclusive). The new dst
++ box is returned. The source boundaries are given (x1, y1
++ inclusive, x2, y2 exclusive) and returned are the new source
++ boundaries in 16.16 fixed point.
++*/
++
++static void
++GLAMOClipVideo(BoxPtr dst, INT32 *x1, INT32 *x2, INT32 *y1, INT32 *y2,
++ BoxPtr extents, INT32 width, INT32 height)
++{
++ INT32 vscale, hscale, delta;
++ int diff;
++
++ hscale = ((*x2 - *x1) << 16) / (dst->x2 - dst->x1);
++ vscale = ((*y2 - *y1) << 16) / (dst->y2 - dst->y1);
++
++ *x1 <<= 16; *x2 <<= 16;
++ *y1 <<= 16; *y2 <<= 16;
++
++ diff = extents->x1 - dst->x1;
++ if (diff > 0) {
++ dst->x1 = extents->x1;
++ *x1 += diff * hscale;
++ }
++ diff = dst->x2 - extents->x2;
++ if (diff > 0) {
++ dst->x2 = extents->x2;
++ *x2 -= diff * hscale;
++ }
++ diff = extents->y1 - dst->y1;
++ if (diff > 0) {
++ dst->y1 = extents->y1;
++ *y1 += diff * vscale;
++ }
++ diff = dst->y2 - extents->y2;
++ if (diff > 0) {
++ dst->y2 = extents->y2;
++ *y2 -= diff * vscale;
++ }
++
++ if (*x1 < 0) {
++ diff = (- *x1 + hscale - 1)/ hscale;
++ dst->x1 += diff;
++ *x1 += diff * hscale;
++ }
++ delta = *x2 - (width << 16);
++ if (delta > 0) {
++ diff = (delta + hscale - 1)/ hscale;
++ dst->x2 -= diff;
++ *x2 -= diff * hscale;
++ }
++ if (*y1 < 0) {
++ diff = (- *y1 + vscale - 1)/ vscale;
++ dst->y1 += diff;
++ *y1 += diff * vscale;
++ }
++ delta = *y2 - (height << 16);
++ if (delta > 0) {
++ diff = (delta + vscale - 1)/ vscale;
++ dst->y2 -= diff;
++ *y2 -= diff * vscale;
++ }
++}
++
++static void
++GlamoDisplayVideo(KdScreenInfo *screen, GLAMOPortPrivPtr pPortPriv)
++{
++ ScreenPtr pScreen = screen->pScreen;
++ KdScreenPriv(pScreen);
++ GLAMOScreenInfo(pScreenPriv);
++ PixmapPtr pPixmap = pPortPriv->pPixmap;
++ CARD32 dst_offset, dst_pitch;
++ int dstxoff, dstyoff, srcDatatype;
++ RING_LOCALS;
++
++ BoxPtr pBox = REGION_RECTS(&pPortPriv->clip);
++ int nBox = REGION_NUM_RECTS(&pPortPriv->clip);
++
++ dst_offset = ((CARD8 *)pPixmap->devPrivate.ptr -
++ pScreenPriv->screen->memory_base);
++ dst_pitch = pPixmap->devKind;
++
++#ifdef COMPOSITE
++ dstxoff = -pPixmap->screen_x + pPixmap->drawable.x;
++ dstyoff = -pPixmap->screen_y + pPixmap->drawable.y;
++#else
++ dstxoff = 0;
++ dstyoff = 0;
++#endif
++
++ BEGIN_DMA(14);
++ OUT_REG(GLAMO_REG_ISP_YUV2RGB_11, 0x0167);
++ OUT_REG(GLAMO_REG_ISP_YUV2RGB_21, 0x01c5);
++ OUT_REG(GLAMO_REG_ISP_YUV2RGB_32, 0x00b6);
++ OUT_REG(GLAMO_REG_ISP_YUV2RGB_33, 0x0058);
++ OUT_REG(GLAMO_REG_ISP_YUV2RGB_RG, 0xb3 << 8 | 0x89);
++ OUT_REG(GLAMO_REG_ISP_YUV2RGB_B, 0xe2);
++
++ /* TODO weight matrix */
++
++ OUT_REG(GLAMO_REG_ISP_PORT2_EN, GLAMO_ISP_PORT2_EN_DECODE);
++
++ END_DMA();
++
++ if (pPortPriv->id == FOURCC_UYVY)
++ srcDatatype = 3;
++ else
++ srcDatatype = 1;
++
++ BEGIN_DMA(8);
++#if 0
++ OUT_REG(GLAMO_REG_ISP_EN3, GLAMO_ISP_EN3_SCALE_IMPROVE |
++ GLAMO_ISP_EN3_PLANE_MODE |
++ GLAMO_ISP_EN3_YUV_INPUT |
++ GLAMO_ISP_EN3_YUV420);
++ OUT_REG(GLAMO_REG_ISP_PORT1_DEC_EN, GLAMO_ISP_PORT1_EN_OUTPUT);
++
++ OUT_REG(GLAMO_REG_ISP_DEC_SCALEH, 1 << 11);
++ OUT_REG(GLAMO_REG_ISP_DEC_SCALEV, 1 << 11);
++
++ {
++ struct {
++ int src_block_y;
++ int src_block_x;
++ int src_block_h;
++ int src_block_w;
++ int jpeg_out_y;
++ int jpeg_out_x;
++ int fifo_full_cnt;
++ int in_length;
++ int fifo_data_cnt;
++ int in_height;
++ } onfly;
++
++ onfly.src_block_y = 32;
++ onfly.src_block_x = 32;
++ onfly.src_block_h = 36;
++ onfly.src_block_w = 35;
++ onfly.jpeg_out_y = 32;
++ onfly.jpeg_out_x = 32;
++ onfly.fifo_full_cnt = 0;
++ onfly.in_length = onfly.jpeg_out_x + 3;
++ onfly.fifo_data_cnt = onfly.src_block_w * onfly.src_block_h / 2;
++ onfly.in_height = onfly.jpeg_out_y + 2;
++
++ OUT_REG(GLAMO_REG_ISP_ONFLY_MODE1, onfly.src_block_y << 10 | onfly.src_block_x << 2);
++ OUT_REG(GLAMO_REG_ISP_ONFLY_MODE2, onfly.src_block_h << 8 | onfly.src_block_w);
++ OUT_REG(GLAMO_REG_ISP_ONFLY_MODE3, onfly.jpeg_out_y << 8 | onfly.jpeg_out_x);
++ OUT_REG(GLAMO_REG_ISP_ONFLY_MODE4, onfly.fifo_full_cnt << 8 | onfly.in_length);
++ OUT_REG(GLAMO_REG_ISP_ONFLY_MODE5, onfly.fifo_data_cnt << 6 | onfly.in_height);
++ }
++#endif
++
++ OUT_REG(GLAMO_REG_ISP_EN1,
++ GLAMO_ISP_EN1_YUV420 |
++ GLAMO_ISP_EN1_YUV_INPUT |
++ GLAMO_ISP_EN1_YUV_PACK |
++ ((srcDatatype << 4) & 0x7));
++
++ OUT_REG(GLAMO_REG_ISP_PORT1_CAP_EN,
++ GLAMO_ISP_PORT1_EN_OUTPUT);
++
++ OUT_REG(GLAMO_REG_ISP_CAP_PITCH, pPortPriv->src_pitch);
++ OUT_REG(GLAMO_REG_ISP_PORT1_CAP_PITCH, dst_pitch);
++
++ END_DMA();
++
++ while (nBox--) {
++ int srcX, srcY, dstX, dstY, srcw, srch, dstw, dsth;
++ CARD32 srcO, dstO;
++
++ dstX = pBox->x1 + dstxoff;
++ dstY = pBox->y1 + dstyoff;
++ dstw = pBox->x2 - pBox->x1;
++ dsth = pBox->y2 - pBox->y1;
++ srcX = (pBox->x1 - pPortPriv->dst_x1) *
++ pPortPriv->src_w / pPortPriv->dst_w;
++ srcY = (pBox->y1 - pPortPriv->dst_y1) *
++ pPortPriv->src_h / pPortPriv->dst_h;
++ srcw = pPortPriv->src_w - srcX; /* XXX */
++ srch = pPortPriv->src_h - srcY; /* XXX */
++
++ srcO = pPortPriv->src_offset + srcY * pPortPriv->src_pitch + srcX * 2;
++ dstO = dst_offset + dstY * dst_pitch + dstX * 2;
++
++ BEGIN_DMA(18);
++
++ OUT_REG(GLAMO_REG_ISP_CAP_0_ADDRL, srcO & 0xffff);
++ OUT_REG(GLAMO_REG_ISP_CAP_0_ADDRH, (srcO >> 16) & 0x7f);
++ OUT_REG(GLAMO_REG_ISP_CAP_HEIGHT, srch);
++ OUT_REG(GLAMO_REG_ISP_CAP_WIDTH, srcw);
++
++ OUT_REG(GLAMO_REG_ISP_PORT1_CAP_0_ADDRL, dstO & 0xffff);
++ OUT_REG(GLAMO_REG_ISP_PORT1_CAP_0_ADDRH, (dstO >> 16) & 0x7f);
++ OUT_REG(GLAMO_REG_ISP_PORT1_CAP_WIDTH, dstw);
++ OUT_REG(GLAMO_REG_ISP_PORT1_CAP_HEIGHT, dsth);
++
++ /* fire */
++ OUT_REG(GLAMO_REG_ISP_EN1, GLAMO_ISP_EN1_FIRE_ISP);
++ OUT_REG(GLAMO_REG_ISP_EN1, 0);
++
++ END_DMA();
++
++ GLAMOWaitIdle(glamos);
++
++ pBox++;
++ }
++#ifdef DAMAGEEXT
++ /* XXX: Shouldn't this be in kxv.c instead? */
++ DamageDamageRegion(pPortPriv->pDraw, &pPortPriv->clip);
++#endif
++ kaaMarkSync(pScreen);
++}
++
++static void
++GLAMOVideoSave(ScreenPtr pScreen, KdOffscreenArea *area)
++{
++ KdScreenPriv(pScreen);
++ GLAMOScreenInfo(pScreenPriv);
++ GLAMOPortPrivPtr pPortPriv = glamos->pAdaptor->pPortPrivates[0].ptr;
++
++ if (pPortPriv->off_screen == area)
++ pPortPriv->off_screen = 0;
++}
++
++static int
++GLAMOPutImage(KdScreenInfo *screen, DrawablePtr pDraw,
++ short src_x, short src_y,
++ short drw_x, short drw_y,
++ short src_w, short src_h,
++ short drw_w, short drw_h,
++ int id,
++ unsigned char *buf,
++ short width,
++ short height,
++ Bool sync,
++ RegionPtr clipBoxes,
++ pointer data)
++{
++ ScreenPtr pScreen = screen->pScreen;
++ KdScreenPriv(pScreen);
++ GLAMOCardInfo(pScreenPriv);
++ GLAMOScreenInfo(pScreenPriv);
++ GLAMOPortPrivPtr pPortPriv = (GLAMOPortPrivPtr)data;
++ char *mmio = glamoc->reg_base;
++ INT32 x1, x2, y1, y2;
++ int randr = RR_Rotate_0 /* XXX */;
++ int srcPitch, srcPitch2, dstPitch;
++ int top, left, npixels, nlines, size;
++ BoxRec dstBox;
++ int dst_width = width, dst_height = height;
++ int rot_x1, rot_y1, rot_x2, rot_y2;
++ int dst_x1, dst_y1, dst_x2, dst_y2;
++ int rot_src_w, rot_src_h, rot_drw_w, rot_drw_h;
++
++ /* Clip */
++ x1 = src_x;
++ x2 = src_x + src_w;
++ y1 = src_y;
++ y2 = src_y + src_h;
++
++ dstBox.x1 = drw_x;
++ dstBox.x2 = drw_x + drw_w;
++ dstBox.y1 = drw_y;
++ dstBox.y2 = drw_y + drw_h;
++
++ GLAMOClipVideo(&dstBox, &x1, &x2, &y1, &y2,
++ REGION_EXTENTS(pScreen, clipBoxes), width, height);
++
++ src_w = (x2 - x1) >> 16;
++ src_h = (y2 - y1) >> 16;
++ drw_w = dstBox.x2 - dstBox.x1;
++ drw_h = dstBox.y2 - dstBox.y1;
++
++ if ((x1 >= x2) || (y1 >= y2))
++ return Success;
++
++ if (mmio == NULL)
++ return BadAlloc;
++
++ if (randr & (RR_Rotate_0|RR_Rotate_180)) {
++ dst_width = width;
++ dst_height = height;
++ rot_src_w = src_w;
++ rot_src_h = src_h;
++ rot_drw_w = drw_w;
++ rot_drw_h = drw_h;
++ } else {
++ dst_width = height;
++ dst_height = width;
++ rot_src_w = src_h;
++ rot_src_h = src_w;
++ rot_drw_w = drw_h;
++ rot_drw_h = drw_w;
++ }
++
++ switch (randr & RR_Rotate_All) {
++ case RR_Rotate_0:
++ default:
++ dst_x1 = dstBox.x1;
++ dst_y1 = dstBox.y1;
++ dst_x2 = dstBox.x2;
++ dst_y2 = dstBox.y2;
++ rot_x1 = x1;
++ rot_y1 = y1;
++ rot_x2 = x2;
++ rot_y2 = y2;
++ break;
++ case RR_Rotate_90:
++ dst_x1 = dstBox.y1;
++ dst_y1 = screen->height - dstBox.x2;
++ dst_x2 = dstBox.y2;
++ dst_y2 = screen->height - dstBox.x1;
++ rot_x1 = y1;
++ rot_y1 = (src_w << 16) - x2;
++ rot_x2 = y2;
++ rot_y2 = (src_w << 16) - x1;
++ break;
++ case RR_Rotate_180:
++ dst_x1 = screen->width - dstBox.x2;
++ dst_y1 = screen->height - dstBox.y2;
++ dst_x2 = screen->width - dstBox.x1;
++ dst_y2 = screen->height - dstBox.y1;
++ rot_x1 = (src_w << 16) - x2;
++ rot_y1 = (src_h << 16) - y2;
++ rot_x2 = (src_w << 16) - x1;
++ rot_y2 = (src_h << 16) - y1;
++ break;
++ case RR_Rotate_270:
++ dst_x1 = screen->width - dstBox.y2;
++ dst_y1 = dstBox.x1;
++ dst_x2 = screen->width - dstBox.y1;
++ dst_y2 = dstBox.x2;
++ rot_x1 = (src_h << 16) - y2;
++ rot_y1 = x1;
++ rot_x2 = (src_h << 16) - y1;
++ rot_y2 = x2;
++ break;
++ }
++
++ switch(id) {
++ case FOURCC_YV12:
++ case FOURCC_I420:
++ dstPitch = ((dst_width << 1) + 15) & ~15;
++ srcPitch = (width + 3) & ~3;
++ srcPitch2 = ((width >> 1) + 3) & ~3;
++ size = dstPitch * dst_height;
++ break;
++ case FOURCC_UYVY:
++ case FOURCC_YUY2:
++ default:
++ dstPitch = ((dst_width << 1) + 15) & ~15;
++ srcPitch = (width << 1);
++ srcPitch2 = 0;
++ size = dstPitch * dst_height;
++ break;
++ }
++
++ if (pPortPriv->off_screen != NULL && size != pPortPriv->size) {
++ KdOffscreenFree(screen->pScreen, pPortPriv->off_screen);
++ pPortPriv->off_screen = 0;
++ }
++
++ if (pPortPriv->off_screen == NULL) {
++ pPortPriv->off_screen = KdOffscreenAlloc(screen->pScreen,
++ size * 2, 64, TRUE, GLAMOVideoSave, pPortPriv);
++ if (pPortPriv->off_screen == NULL)
++ return BadAlloc;
++ }
++
++
++ if (pDraw->type == DRAWABLE_WINDOW)
++ pPortPriv->pPixmap =
++ (*pScreen->GetWindowPixmap)((WindowPtr)pDraw);
++ else
++ pPortPriv->pPixmap = (PixmapPtr)pDraw;
++
++ /* Migrate the pixmap to offscreen if necessary. */
++ if (!kaaPixmapIsOffscreen(pPortPriv->pPixmap))
++ kaaMoveInPixmap(pPortPriv->pPixmap);
++
++ if (!kaaPixmapIsOffscreen(pPortPriv->pPixmap)) {
++ return BadAlloc;
++ }
++
++ pPortPriv->src_offset = pPortPriv->off_screen->offset;
++ pPortPriv->src_addr = (CARD8 *)(pScreenPriv->screen->memory_base +
++ pPortPriv->src_offset);
++ pPortPriv->src_pitch = dstPitch;
++ pPortPriv->size = size;
++ pPortPriv->pDraw = pDraw;
++
++ /* copy data */
++ top = rot_y1 >> 16;
++ left = (rot_x1 >> 16) & ~1;
++ npixels = ((((rot_x2 + 0xffff) >> 16) + 1) & ~1) - left;
++
++ /* Since we're probably overwriting the area that might still be used
++ * for the last PutImage request, wait for idle.
++ */
++ GLAMOWaitIdle(glamos);
++
++ switch(id) {
++ case FOURCC_YV12:
++ case FOURCC_I420:
++ top &= ~1;
++ nlines = ((((rot_y2 + 0xffff) >> 16) + 1) & ~1) - top;
++ /* pack the source as YUY2 to vram */
++ KdXVCopyPlanarData(screen, buf, pPortPriv->src_addr, randr,
++ srcPitch, srcPitch2, dstPitch, rot_src_w, rot_src_h,
++ height, top, left, nlines, npixels, id);
++ break;
++ case FOURCC_UYVY:
++ case FOURCC_YUY2:
++ default:
++ nlines = ((rot_y2 + 0xffff) >> 16) - top;
++ KdXVCopyPackedData(screen, buf, pPortPriv->src_addr, randr,
++ srcPitch, dstPitch, rot_src_w, rot_src_h, top, left,
++ nlines, npixels);
++ break;
++ }
++
++ /* update cliplist */
++ if (!REGION_EQUAL(screen->pScreen, &pPortPriv->clip, clipBoxes)) {
++ REGION_COPY(screen->pScreen, &pPortPriv->clip, clipBoxes);
++ }
++
++ pPortPriv->id = id;
++ pPortPriv->src_x1 = rot_x1;
++ pPortPriv->src_y1 = rot_y1;
++ pPortPriv->src_x2 = rot_x2;
++ pPortPriv->src_y2 = rot_y2;
++ pPortPriv->src_w = rot_src_w;
++ pPortPriv->src_h = rot_src_h;
++ pPortPriv->dst_x1 = dst_x1;
++ pPortPriv->dst_y1 = dst_y1;
++ pPortPriv->dst_x2 = dst_x2;
++ pPortPriv->dst_y2 = dst_y2;
++ pPortPriv->dst_w = rot_drw_w;
++ pPortPriv->dst_h = rot_drw_h;
++
++ GlamoDisplayVideo(screen, pPortPriv);
++
++ return Success;
++}
++
++static int
++GLAMOReputImage(KdScreenInfo *screen, DrawablePtr pDraw, short drw_x, short drw_y,
++ RegionPtr clipBoxes, pointer data)
++{
++ ScreenPtr pScreen = screen->pScreen;
++ GLAMOPortPrivPtr pPortPriv = (GLAMOPortPrivPtr)data;
++ BoxPtr pOldExtents = REGION_EXTENTS(screen->pScreen, &pPortPriv->clip);
++ BoxPtr pNewExtents = REGION_EXTENTS(screen->pScreen, clipBoxes);
++
++ if (pOldExtents->x1 != pNewExtents->x1 ||
++ pOldExtents->x2 != pNewExtents->x2 ||
++ pOldExtents->y1 != pNewExtents->y1 ||
++ pOldExtents->y2 != pNewExtents->y2)
++ return BadMatch;
++
++ if (pDraw->type == DRAWABLE_WINDOW)
++ pPortPriv->pPixmap =
++ (*pScreen->GetWindowPixmap)((WindowPtr)pDraw);
++ else
++ pPortPriv->pPixmap = (PixmapPtr)pDraw;
++
++ if (!kaaPixmapIsOffscreen(pPortPriv->pPixmap))
++ kaaMoveInPixmap(pPortPriv->pPixmap);
++
++ if (!kaaPixmapIsOffscreen(pPortPriv->pPixmap)) {
++ ErrorF("err\n");
++ return BadAlloc;
++ }
++
++
++ /* update cliplist */
++ if (!REGION_EQUAL(screen->pScreen, &pPortPriv->clip, clipBoxes))
++ REGION_COPY(screen->pScreen, &pPortPriv->clip, clipBoxes);
++
++ /* XXX: What do the drw_x and drw_y here mean for us? */
++
++ GlamoDisplayVideo(screen, pPortPriv);
++
++ return Success;
++}
++
++static int
++GLAMOQueryImageAttributes(KdScreenInfo *screen, int id, unsigned short *w,
++ unsigned short *h, int *pitches, int *offsets)
++{
++ int size, tmp;
++
++ if (*w > IMAGE_MAX_WIDTH)
++ *w = IMAGE_MAX_WIDTH;
++ if (*h > IMAGE_MAX_HEIGHT)
++ *h = IMAGE_MAX_HEIGHT;
++
++ *w = (*w + 1) & ~1;
++ if (offsets)
++ offsets[0] = 0;
++
++ switch (id)
++ {
++ case FOURCC_YV12:
++ case FOURCC_I420:
++ *h = (*h + 1) & ~1;
++ size = (*w + 3) & ~3;
++ if (pitches)
++ pitches[0] = size;
++ size *= *h;
++ if (offsets)
++ offsets[1] = size;
++ tmp = ((*w >> 1) + 3) & ~3;
++ if (pitches)
++ pitches[1] = pitches[2] = tmp;
++ tmp *= (*h >> 1);
++ size += tmp;
++ if (offsets)
++ offsets[2] = size;
++ size += tmp;
++ break;
++ case FOURCC_UYVY:
++ case FOURCC_YUY2:
++ default:
++ size = *w << 1;
++ if (pitches)
++ pitches[0] = size;
++ size *= *h;
++ break;
++ }
++
++ return size;
++}
++
++
++/* client libraries expect an encoding */
++static KdVideoEncodingRec DummyEncoding[1] =
++{
++ {
++ 0,
++ "XV_IMAGE",
++ IMAGE_MAX_WIDTH, IMAGE_MAX_HEIGHT,
++ {1, 1}
++ }
++};
++
++#define NUM_FORMATS 1
++
++static KdVideoFormatRec Formats[NUM_FORMATS] =
++{
++ {16, TrueColor}
++};
++
++#define NUM_ATTRIBUTES 0
++
++static KdAttributeRec Attributes[NUM_ATTRIBUTES] =
++{
++};
++
++#define NUM_IMAGES 4
++
++static KdImageRec Images[NUM_IMAGES] =
++{
++ XVIMAGE_YUY2,
++ XVIMAGE_YV12,
++ XVIMAGE_I420,
++ XVIMAGE_UYVY
++};
++
++static KdVideoAdaptorPtr
++GLAMOSetupImageVideo(ScreenPtr pScreen)
++{
++ KdScreenPriv(pScreen);
++ GLAMOScreenInfo(pScreenPriv);
++ KdVideoAdaptorPtr adapt;
++ GLAMOPortPrivPtr pPortPriv;
++ int i;
++
++ glamos->num_texture_ports = 16;
++
++ adapt = xcalloc(1, sizeof(KdVideoAdaptorRec) + glamos->num_texture_ports *
++ (sizeof(GLAMOPortPrivRec) + sizeof(DevUnion)));
++ if (adapt == NULL)
++ return NULL;
++
++ adapt->type = XvWindowMask | XvInputMask | XvImageMask;
++ adapt->flags = VIDEO_CLIP_TO_VIEWPORT;
++ adapt->name = "GLAMO Texture Video";
++ adapt->nEncodings = 1;
++ adapt->pEncodings = DummyEncoding;
++ adapt->nFormats = NUM_FORMATS;
++ adapt->pFormats = Formats;
++ adapt->nPorts = glamos->num_texture_ports;
++ adapt->pPortPrivates = (DevUnion*)(&adapt[1]);
++
++ pPortPriv =
++ (GLAMOPortPrivPtr)(&adapt->pPortPrivates[glamos->num_texture_ports]);
++
++ for (i = 0; i < glamos->num_texture_ports; i++)
++ adapt->pPortPrivates[i].ptr = &pPortPriv[i];
++
++ adapt->nAttributes = NUM_ATTRIBUTES;
++ adapt->pAttributes = Attributes;
++ adapt->pImages = Images;
++ adapt->nImages = NUM_IMAGES;
++ adapt->PutVideo = NULL;
++ adapt->PutStill = NULL;
++ adapt->GetVideo = NULL;
++ adapt->GetStill = NULL;
++ adapt->StopVideo = GLAMOStopVideo;
++ adapt->SetPortAttribute = GLAMOSetPortAttribute;
++ adapt->GetPortAttribute = GLAMOGetPortAttribute;
++ adapt->QueryBestSize = GLAMOQueryBestSize;
++ adapt->PutImage = GLAMOPutImage;
++ adapt->ReputImage = GLAMOReputImage;
++ adapt->QueryImageAttributes = GLAMOQueryImageAttributes;
++
++ /* gotta uninit this someplace */
++ REGION_INIT(pScreen, &pPortPriv->clip, NullBox, 0);
++
++ glamos->pAdaptor = adapt;
++
++ xvBrightness = MAKE_ATOM("XV_BRIGHTNESS");
++ xvSaturation = MAKE_ATOM("XV_SATURGLAMOON");
++
++ return adapt;
++}
++
++static void GLAMOPowerUp(ScreenPtr pScreen)
++{
++ GLAMOEngineEnable(pScreen, GLAMO_ENGINE_ISP);
++ GLAMOEngineReset(pScreen, GLAMO_ENGINE_ISP);
++
++ /* HW_DEBUG_0?? */
++ //MMIOSetBitMask(mmio, REG_ISP(0x102), 0x0020, 0);
++}
++
++static void GLAMOPowerDown(ScreenPtr pScreen)
++{
++ GLAMOEngineReset(pScreen, GLAMO_ENGINE_ISP);
++
++ /* ... and stop the clock */
++}
++
++Bool GLAMOInitVideo(ScreenPtr pScreen)
++{
++ KdScreenPriv(pScreen);
++ GLAMOScreenInfo(pScreenPriv);
++ GLAMOCardInfo(pScreenPriv);
++ KdScreenInfo *screen = pScreenPriv->screen;
++ KdVideoAdaptorPtr *adaptors, *newAdaptors = NULL;
++ KdVideoAdaptorPtr newAdaptor = NULL;
++ int num_adaptors;
++
++ glamos->pAdaptor = NULL;
++
++ if (glamoc->reg_base == NULL)
++ return FALSE;
++
++ num_adaptors = KdXVListGenericAdaptors(screen, &adaptors);
++
++ newAdaptor = GLAMOSetupImageVideo(pScreen);
++
++ if (newAdaptor) {
++ GLAMOPowerUp(pScreen);
++
++ if (!num_adaptors) {
++ num_adaptors = 1;
++ adaptors = &newAdaptor;
++ } else {
++ newAdaptors = xalloc((num_adaptors + 1) *
++ sizeof(KdVideoAdaptorPtr *));
++ if (newAdaptors) {
++ memcpy(newAdaptors, adaptors, num_adaptors *
++ sizeof(KdVideoAdaptorPtr));
++ newAdaptors[num_adaptors] = newAdaptor;
++ adaptors = newAdaptors;
++ num_adaptors++;
++ }
++ }
++ }
++
++ if (num_adaptors)
++ KdXVScreenInit(pScreen, adaptors, num_adaptors);
++
++ if (newAdaptors)
++ xfree(newAdaptors);
++
++ return TRUE;
++}
++
++void
++GLAMOFiniVideo(ScreenPtr pScreen)
++{
++ KdScreenPriv(pScreen);
++ GLAMOScreenInfo(pScreenPriv);
++ KdVideoAdaptorPtr adapt = glamos->pAdaptor;
++ GLAMOPortPrivPtr pPortPriv;
++ int i;
++
++ if (!adapt)
++ return;
++
++ GLAMOPowerDown(pScreen);
++
++ for (i = 0; i < glamos->num_texture_ports; i++) {
++ pPortPriv = (GLAMOPortPrivPtr)(&adapt->pPortPrivates[i].ptr);
++ REGION_UNINIT(pScreen, &pPortPriv->clip);
++ }
++ xfree(adapt);
++ glamos->pAdaptor = NULL;
++}
git.openpandora.org / openembedded.git / commitdiff