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 + * 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 +#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 +#endif + +#ifdef KDRIVEFBDEV +#include +#endif +#ifdef KDRIVEVESA +#include +#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 + +#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 +#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 +#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 +#endif +#include "glamo.h" +#include "glamo_dma.h" +#include "glamo_draw.h" +#include "glamo-regs.h" +#include "kaa.h" + +#include +#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; +}