frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
xserver/hw/xfree86/ramdac/IBM.c

644 lines
22 KiB
C
Raw Blame History

/*
* Copyright 1998 by Alan Hourihane, Wigan, England.
*
* 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 Alan Hourihane not be used in
* advertising or publicity pertaining to distribution of the software without
* specific, written prior permission. Alan Hourihane makes no representations
* about the suitability of this software for any purpose. It is provided
* "as is" without express or implied warranty.
*
* ALAN HOURIHANE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL ALAN HOURIHANE 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.
*
* Authors: Alan Hourihane, <alanh@fairlite.demon.co.uk>
*
* IBM RAMDAC routines.
*/
#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif
#include "xf86.h"
#include "xf86_OSproc.h"
#include "xf86Cursor.h"
#define INIT_IBM_RAMDAC_INFO
#include "IBMPriv.h"
#include "xf86RamDacPriv.h"
#define INITIALFREQERR 100000
unsigned long
IBMramdac640CalculateMNPCForClock(unsigned long RefClock, /* In 100Hz units */
unsigned long ReqClock, /* In 100Hz units */
char IsPixClock, /* boolean, is this the pixel or the sys clock */
unsigned long MinClock, /* Min VCO rating */
unsigned long MaxClock, /* Max VCO rating */
unsigned long *rM, /* M Out */
unsigned long *rN, /* N Out */
unsigned long *rP, /* Min P In, P Out */
unsigned long *rC /* C Out */
)
{
unsigned long M, N, P, iP = *rP;
unsigned long IntRef, VCO, Clock;
long freqErr, lowestFreqErr = INITIALFREQERR;
unsigned long ActualClock = 0;
for (N = 0; N <= 63; N++) {
IntRef = RefClock / (N + 1);
if (IntRef < 10000)
break; /* IntRef needs to be >= 1MHz */
for (M = 2; M <= 127; M++) {
VCO = IntRef * (M + 1);
if ((VCO < MinClock) || (VCO > MaxClock))
continue;
for (P = iP; P <= 4; P++) {
if (P != 0)
Clock = (RefClock * (M + 1)) / ((N + 1) * 2 * P);
else
Clock = (RefClock * (M + 1)) / (N + 1);
freqErr = (Clock - ReqClock);
if (freqErr < 0) {
/* PixelClock gets rounded up always so monitor reports
correct frequency. */
if (IsPixClock)
continue;
freqErr = -freqErr;
}
if (freqErr < lowestFreqErr) {
*rM = M;
*rN = N;
*rP = P;
*rC = (VCO <= 1280000 ? 1 : 2);
ActualClock = Clock;
lowestFreqErr = freqErr;
/* Return if we found an exact match */
if (freqErr == 0)
return ActualClock;
}
}
}
}
return ActualClock;
}
unsigned long
IBMramdac526CalculateMNPCForClock(unsigned long RefClock, /* In 100Hz units */
unsigned long ReqClock, /* In 100Hz units */
char IsPixClock, /* boolean, is this the pixel or the sys clock */
unsigned long MinClock, /* Min VCO rating */
unsigned long MaxClock, /* Max VCO rating */
unsigned long *rM, /* M Out */
unsigned long *rN, /* N Out */
unsigned long *rP, /* Min P In, P Out */
unsigned long *rC /* C Out */
)
{
unsigned long M, N, P, iP = *rP;
unsigned long IntRef, VCO, Clock;
long freqErr, lowestFreqErr = INITIALFREQERR;
unsigned long ActualClock = 0;
for (N = 0; N <= 63; N++) {
IntRef = RefClock / (N + 1);
if (IntRef < 10000)
break; /* IntRef needs to be >= 1MHz */
for (M = 0; M <= 63; M++) {
VCO = IntRef * (M + 1);
if ((VCO < MinClock) || (VCO > MaxClock))
continue;
for (P = iP; P <= 4; P++) {
if (P)
Clock = (RefClock * (M + 1)) / ((N + 1) * 2 * P);
else
Clock = VCO;
freqErr = (Clock - ReqClock);
if (freqErr < 0) {
/* PixelClock gets rounded up always so monitor reports
correct frequency. */
if (IsPixClock)
continue;
freqErr = -freqErr;
}
if (freqErr < lowestFreqErr) {
*rM = M;
*rN = N;
*rP = P;
*rC = (VCO <= 1280000 ? 1 : 2);
ActualClock = Clock;
lowestFreqErr = freqErr;
/* Return if we found an exact match */
if (freqErr == 0)
return ActualClock;
}
}
}
}
return ActualClock;
}
void
IBMramdacRestore(ScrnInfoPtr pScrn, RamDacRecPtr ramdacPtr,
RamDacRegRecPtr ramdacReg)
{
int i, maxreg, dacreg;
switch (ramdacPtr->RamDacType) {
case IBM640_RAMDAC:
maxreg = 0x300;
dacreg = 1024;
break;
default:
maxreg = 0x100;
dacreg = 768;
break;
}
/* Here we pass a short, so that we can evaluate a mask too */
/* So that the mask is the high byte and the data the low byte */
for (i = 0; i < maxreg; i++)
(*ramdacPtr->WriteDAC)
(pScrn, i, (ramdacReg->DacRegs[i] & 0xFF00) >> 8,
ramdacReg->DacRegs[i]);
(*ramdacPtr->WriteAddress) (pScrn, 0);
for (i = 0; i < dacreg; i++)
(*ramdacPtr->WriteData) (pScrn, ramdacReg->DAC[i]);
}
void
IBMramdacSave(ScrnInfoPtr pScrn, RamDacRecPtr ramdacPtr,
RamDacRegRecPtr ramdacReg)
{
int i, maxreg, dacreg;
switch (ramdacPtr->RamDacType) {
case IBM640_RAMDAC:
maxreg = 0x300;
dacreg = 1024;
break;
default:
maxreg = 0x100;
dacreg = 768;
break;
}
(*ramdacPtr->ReadAddress) (pScrn, 0);
for (i = 0; i < dacreg; i++)
ramdacReg->DAC[i] = (*ramdacPtr->ReadData) (pScrn);
for (i = 0; i < maxreg; i++)
ramdacReg->DacRegs[i] = (*ramdacPtr->ReadDAC) (pScrn, i);
}
RamDacHelperRecPtr
IBMramdacProbe(ScrnInfoPtr pScrn,
RamDacSupportedInfoRecPtr ramdacs /* , RamDacRecPtr ramdacPtr */
)
{
RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
RamDacHelperRecPtr ramdacHelperPtr = NULL;
Bool RamDacIsSupported = FALSE;
int IBMramdac_ID = -1;
int i;
unsigned char id, rev, id2, rev2;
/* read ID and revision */
rev = (*ramdacPtr->ReadDAC) (pScrn, IBMRGB_rev);
id = (*ramdacPtr->ReadDAC) (pScrn, IBMRGB_id);
/* check if ID and revision are read only */
(*ramdacPtr->WriteDAC) (pScrn, ~rev, 0, IBMRGB_rev);
(*ramdacPtr->WriteDAC) (pScrn, ~id, 0, IBMRGB_id);
rev2 = (*ramdacPtr->ReadDAC) (pScrn, IBMRGB_rev);
id2 = (*ramdacPtr->ReadDAC) (pScrn, IBMRGB_id);
switch (id) {
case 0x30:
if (rev == 0xc0)
IBMramdac_ID = IBM624_RAMDAC;
if (rev == 0x80)
IBMramdac_ID = IBM624DB_RAMDAC;
break;
case 0x12:
if (rev == 0x1c)
IBMramdac_ID = IBM640_RAMDAC;
break;
case 0x01:
IBMramdac_ID = IBM525_RAMDAC;
break;
case 0x02:
if (rev == 0xf0)
IBMramdac_ID = IBM524_RAMDAC;
if (rev == 0xe0)
IBMramdac_ID = IBM524A_RAMDAC;
if (rev == 0xc0)
IBMramdac_ID = IBM526_RAMDAC;
if (rev == 0x80)
IBMramdac_ID = IBM526DB_RAMDAC;
break;
}
if (id == 1 || id == 2) {
if (id == id2 && rev == rev2) { /* IBM RGB52x found */
/* check for 128bit VRAM -> RGB528 */
if (((*ramdacPtr->ReadDAC) (pScrn, IBMRGB_misc1) & 0x03) == 0x03) {
IBMramdac_ID = IBM528_RAMDAC; /* 128bit DAC found */
if (rev == 0xe0)
IBMramdac_ID = IBM528A_RAMDAC;
}
}
}
(*ramdacPtr->WriteDAC) (pScrn, rev, 0, IBMRGB_rev);
(*ramdacPtr->WriteDAC) (pScrn, id, 0, IBMRGB_id);
if (IBMramdac_ID == -1) {
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"Cannot determine IBM RAMDAC type, aborting\n");
return NULL;
}
else {
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"Attached RAMDAC is %s\n",
IBMramdacDeviceInfo[IBMramdac_ID & 0xFFFF].DeviceName);
}
for (i = 0; ramdacs[i].token != -1; i++) {
if (ramdacs[i].token == IBMramdac_ID)
RamDacIsSupported = TRUE;
}
if (!RamDacIsSupported) {
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"This IBM RAMDAC is NOT supported by this driver, aborting\n");
return NULL;
}
ramdacHelperPtr = RamDacHelperCreateInfoRec();
switch (IBMramdac_ID) {
case IBM526_RAMDAC:
case IBM526DB_RAMDAC:
ramdacHelperPtr->SetBpp = IBMramdac526SetBpp;
ramdacHelperPtr->HWCursorInit = IBMramdac526HWCursorInit;
break;
case IBM640_RAMDAC:
ramdacHelperPtr->SetBpp = IBMramdac640SetBpp;
ramdacHelperPtr->HWCursorInit = IBMramdac640HWCursorInit;
break;
}
ramdacPtr->RamDacType = IBMramdac_ID;
ramdacHelperPtr->RamDacType = IBMramdac_ID;
ramdacHelperPtr->Save = IBMramdacSave;
ramdacHelperPtr->Restore = IBMramdacRestore;
return ramdacHelperPtr;
}
void
IBMramdac526SetBpp(ScrnInfoPtr pScrn, RamDacRegRecPtr ramdacReg)
{
ramdacReg->DacRegs[IBMRGB_key_control] = 0x00; /* Disable Chroma Key */
switch (pScrn->bitsPerPixel) {
case 32:
ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_32BPP;
ramdacReg->DacRegs[IBMRGB_32bpp] = B32_DCOL_DIRECT;
ramdacReg->DacRegs[IBMRGB_24bpp] = 0;
ramdacReg->DacRegs[IBMRGB_16bpp] = 0;
ramdacReg->DacRegs[IBMRGB_8bpp] = 0;
if (pScrn->overlayFlags & OVERLAY_8_32_PLANAR) {
ramdacReg->DacRegs[IBMRGB_key_control] = 0x01; /* Enable Key */
ramdacReg->DacRegs[IBMRGB_key] = 0xFF;
ramdacReg->DacRegs[IBMRGB_key_mask] = 0xFF;
}
break;
case 24:
ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_24BPP;
ramdacReg->DacRegs[IBMRGB_32bpp] = 0;
ramdacReg->DacRegs[IBMRGB_24bpp] = B24_DCOL_DIRECT;
ramdacReg->DacRegs[IBMRGB_16bpp] = 0;
ramdacReg->DacRegs[IBMRGB_8bpp] = 0;
break;
case 16:
if (pScrn->depth == 16) {
ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_16BPP;
ramdacReg->DacRegs[IBMRGB_32bpp] = 0;
ramdacReg->DacRegs[IBMRGB_24bpp] = 0;
ramdacReg->DacRegs[IBMRGB_16bpp] = B16_DCOL_DIRECT | B16_LINEAR |
B16_CONTIGUOUS | B16_565;
ramdacReg->DacRegs[IBMRGB_8bpp] = 0;
}
else {
ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_16BPP;
ramdacReg->DacRegs[IBMRGB_32bpp] = 0;
ramdacReg->DacRegs[IBMRGB_24bpp] = 0;
ramdacReg->DacRegs[IBMRGB_16bpp] = B16_DCOL_DIRECT | B16_LINEAR |
B16_CONTIGUOUS | B16_555;
ramdacReg->DacRegs[IBMRGB_8bpp] = 0;
}
break;
case 8:
ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_8BPP;
ramdacReg->DacRegs[IBMRGB_32bpp] = 0;
ramdacReg->DacRegs[IBMRGB_24bpp] = 0;
ramdacReg->DacRegs[IBMRGB_16bpp] = 0;
ramdacReg->DacRegs[IBMRGB_8bpp] = B8_DCOL_INDIRECT;
break;
case 4:
ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_4BPP;
ramdacReg->DacRegs[IBMRGB_32bpp] = 0;
ramdacReg->DacRegs[IBMRGB_24bpp] = 0;
ramdacReg->DacRegs[IBMRGB_16bpp] = 0;
ramdacReg->DacRegs[IBMRGB_8bpp] = 0;
}
}
IBMramdac526SetBppProc *
IBMramdac526SetBppWeak(void)
{
return IBMramdac526SetBpp;
}
void
IBMramdac640SetBpp(ScrnInfoPtr pScrn, RamDacRegRecPtr ramdacReg)
{
unsigned char bpp = 0x00;
unsigned char overlaybpp = 0x00;
unsigned char offset = 0x00;
unsigned char dispcont = 0x44;
ramdacReg->DacRegs[RGB640_SER_WID_03_00] = 0x00;
ramdacReg->DacRegs[RGB640_SER_WID_07_04] = 0x00;
ramdacReg->DacRegs[RGB640_DIAGS] = 0x07;
switch (pScrn->depth) {
case 8:
ramdacReg->DacRegs[RGB640_SER_07_00] = 0x00;
ramdacReg->DacRegs[RGB640_SER_15_08] = 0x00;
ramdacReg->DacRegs[RGB640_SER_23_16] = 0x00;
ramdacReg->DacRegs[RGB640_SER_31_24] = 0x00;
ramdacReg->DacRegs[RGB640_SER_MODE] = IBM640_SER_16_1; /*16:1 Mux */
ramdacReg->DacRegs[RGB640_MISC_CONF] = IBM640_PCLK_8; /* pll / 8 */
bpp = 0x03;
break;
case 15:
ramdacReg->DacRegs[RGB640_SER_07_00] = 0x10;
ramdacReg->DacRegs[RGB640_SER_15_08] = 0x11;
ramdacReg->DacRegs[RGB640_SER_23_16] = 0x00;
ramdacReg->DacRegs[RGB640_SER_31_24] = 0x00;
ramdacReg->DacRegs[RGB640_SER_MODE] = IBM640_SER_8_1; /* 8:1 Mux */
ramdacReg->DacRegs[RGB640_MISC_CONF] = IBM640_PCLK_8; /* pll / 8 */
bpp = 0x0E;
break;
case 16:
ramdacReg->DacRegs[RGB640_SER_07_00] = 0x10;
ramdacReg->DacRegs[RGB640_SER_15_08] = 0x11;
ramdacReg->DacRegs[RGB640_SER_23_16] = 0x00;
ramdacReg->DacRegs[RGB640_SER_31_24] = 0x00;
ramdacReg->DacRegs[RGB640_SER_MODE] = IBM640_SER_8_1; /* 8:1 Mux */
ramdacReg->DacRegs[RGB640_MISC_CONF] = IBM640_PCLK_8; /* pll / 8 */
bpp = 0x05;
break;
case 24:
ramdacReg->DacRegs[RGB640_SER_07_00] = 0x30;
ramdacReg->DacRegs[RGB640_SER_15_08] = 0x31;
ramdacReg->DacRegs[RGB640_SER_23_16] = 0x32;
ramdacReg->DacRegs[RGB640_SER_31_24] = 0x33;
ramdacReg->DacRegs[RGB640_SER_MODE] = IBM640_SER_4_1; /* 4:1 Mux */
ramdacReg->DacRegs[RGB640_MISC_CONF] = IBM640_PCLK_8; /* pll / 8 */
bpp = 0x09;
if (pScrn->overlayFlags & OVERLAY_8_32_PLANAR) {
ramdacReg->DacRegs[RGB640_SER_WID_07_04] = 0x04;
ramdacReg->DacRegs[RGB640_CHROMA_KEY0] = 0xFF;
ramdacReg->DacRegs[RGB640_CHROMA_MASK0] = 0xFF;
offset = 0x04;
overlaybpp = 0x04;
dispcont = 0x48;
}
break;
case 30: /* 10 bit dac */
ramdacReg->DacRegs[RGB640_SER_07_00] = 0x30;
ramdacReg->DacRegs[RGB640_SER_15_08] = 0x31;
ramdacReg->DacRegs[RGB640_SER_23_16] = 0x32;
ramdacReg->DacRegs[RGB640_SER_31_24] = 0x33;
ramdacReg->DacRegs[RGB640_SER_MODE] = IBM640_SER_4_1; /* 4:1 Mux */
ramdacReg->DacRegs[RGB640_MISC_CONF] = IBM640_PSIZE10 | IBM640_PCLK_8; /* pll / 8 */
bpp = 0x0D;
break;
}
{
int i;
for (i = 0x100; i < 0x140; i += 4) {
/* Initialize FrameBuffer Window Attribute Table */
ramdacReg->DacRegs[i + 0] = bpp;
ramdacReg->DacRegs[i + 1] = offset;
ramdacReg->DacRegs[i + 2] = 0x00;
ramdacReg->DacRegs[i + 3] = 0x00;
/* Initialize Overlay Window Attribute Table */
ramdacReg->DacRegs[i + 0x100] = overlaybpp;
ramdacReg->DacRegs[i + 0x101] = 0x00;
ramdacReg->DacRegs[i + 0x102] = 0x00;
ramdacReg->DacRegs[i + 0x103] = dispcont;
}
}
}
static void
IBMramdac526ShowCursor(ScrnInfoPtr pScrn)
{
RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
/* Enable cursor - X11 mode */
(*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs, 0x00, 0x07);
}
static void
IBMramdac640ShowCursor(ScrnInfoPtr pScrn)
{
RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
/* Enable cursor - mode2 (x11 mode) */
(*ramdacPtr->WriteDAC) (pScrn, RGB640_CURSOR_CONTROL, 0x00, 0x0B);
(*ramdacPtr->WriteDAC) (pScrn, RGB640_CROSSHAIR_CONTROL, 0x00, 0x00);
}
static void
IBMramdac526HideCursor(ScrnInfoPtr pScrn)
{
RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
/* Disable cursor - X11 mode */
(*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs, 0x00, 0x24);
}
static void
IBMramdac640HideCursor(ScrnInfoPtr pScrn)
{
RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
/* Disable cursor - mode2 (x11 mode) */
(*ramdacPtr->WriteDAC) (pScrn, RGB640_CURSOR_CONTROL, 0x00, 0x08);
}
static void
IBMramdac526SetCursorPosition(ScrnInfoPtr pScrn, int x, int y)
{
RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
x += 64;
y += 64;
(*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs_hot_x, 0x00, 0x3f);
(*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs_hot_y, 0x00, 0x3f);
(*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs_xl, 0x00, x & 0xff);
(*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs_xh, 0x00, (x >> 8) & 0xf);
(*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs_yl, 0x00, y & 0xff);
(*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs_yh, 0x00, (y >> 8) & 0xf);
}
static void
IBMramdac640SetCursorPosition(ScrnInfoPtr pScrn, int x, int y)
{
RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
x += 64;
y += 64;
(*ramdacPtr->WriteDAC) (pScrn, RGB640_CURS_OFFSETX, 0x00, 0x3f);
(*ramdacPtr->WriteDAC) (pScrn, RGB640_CURS_OFFSETY, 0x00, 0x3f);
(*ramdacPtr->WriteDAC) (pScrn, RGB640_CURS_X_LOW, 0x00, x & 0xff);
(*ramdacPtr->WriteDAC) (pScrn, RGB640_CURS_X_HIGH, 0x00, (x >> 8) & 0xf);
(*ramdacPtr->WriteDAC) (pScrn, RGB640_CURS_Y_LOW, 0x00, y & 0xff);
(*ramdacPtr->WriteDAC) (pScrn, RGB640_CURS_Y_HIGH, 0x00, (y >> 8) & 0xf);
}
static void
IBMramdac526SetCursorColors(ScrnInfoPtr pScrn, int bg, int fg)
{
RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
(*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs_col1_r, 0x00, bg >> 16);
(*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs_col1_g, 0x00, bg >> 8);
(*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs_col1_b, 0x00, bg);
(*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs_col2_r, 0x00, fg >> 16);
(*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs_col2_g, 0x00, fg >> 8);
(*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs_col2_b, 0x00, fg);
}
static void
IBMramdac640SetCursorColors(ScrnInfoPtr pScrn, int bg, int fg)
{
RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
(*ramdacPtr->WriteDAC) (pScrn, RGB640_CURS_COL0, 0x00, 0);
(*ramdacPtr->WriteData) (pScrn, fg >> 16);
(*ramdacPtr->WriteData) (pScrn, fg >> 8);
(*ramdacPtr->WriteData) (pScrn, fg);
(*ramdacPtr->WriteData) (pScrn, bg >> 16);
(*ramdacPtr->WriteData) (pScrn, bg >> 8);
(*ramdacPtr->WriteData) (pScrn, bg);
(*ramdacPtr->WriteData) (pScrn, fg >> 16);
(*ramdacPtr->WriteData) (pScrn, fg >> 8);
(*ramdacPtr->WriteData) (pScrn, fg);
(*ramdacPtr->WriteData) (pScrn, bg >> 16);
(*ramdacPtr->WriteData) (pScrn, bg >> 8);
(*ramdacPtr->WriteData) (pScrn, bg);
}
static void
IBMramdac526LoadCursorImage(ScrnInfoPtr pScrn, unsigned char *src)
{
RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
int i;
/*
* Output the cursor data. The realize function has put the planes into
* their correct order, so we can just blast this out.
*/
for (i = 0; i < 1024; i++)
(*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs_array + i, 0x00, (*src++));
}
static void
IBMramdac640LoadCursorImage(ScrnInfoPtr pScrn, unsigned char *src)
{
RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
int i;
/*
* Output the cursor data. The realize function has put the planes into
* their correct order, so we can just blast this out.
*/
for (i = 0; i < 1024; i++)
(*ramdacPtr->WriteDAC) (pScrn, RGB640_CURS_WRITE + i, 0x00, (*src++));
}
static Bool
IBMramdac526UseHWCursor(ScreenPtr pScr, CursorPtr pCurs)
{
return TRUE;
}
static Bool
IBMramdac640UseHWCursor(ScreenPtr pScr, CursorPtr pCurs)
{
return TRUE;
}
void
IBMramdac526HWCursorInit(xf86CursorInfoPtr infoPtr)
{
infoPtr->MaxWidth = 64;
infoPtr->MaxHeight = 64;
infoPtr->Flags = HARDWARE_CURSOR_TRUECOLOR_AT_8BPP |
HARDWARE_CURSOR_AND_SOURCE_WITH_MASK |
HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_1;
infoPtr->SetCursorColors = IBMramdac526SetCursorColors;
infoPtr->SetCursorPosition = IBMramdac526SetCursorPosition;
infoPtr->LoadCursorImage = IBMramdac526LoadCursorImage;
infoPtr->HideCursor = IBMramdac526HideCursor;
infoPtr->ShowCursor = IBMramdac526ShowCursor;
infoPtr->UseHWCursor = IBMramdac526UseHWCursor;
}
void
IBMramdac640HWCursorInit(xf86CursorInfoPtr infoPtr)
{
infoPtr->MaxWidth = 64;
infoPtr->MaxHeight = 64;
infoPtr->Flags = HARDWARE_CURSOR_TRUECOLOR_AT_8BPP |
HARDWARE_CURSOR_AND_SOURCE_WITH_MASK |
HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_1;
infoPtr->SetCursorColors = IBMramdac640SetCursorColors;
infoPtr->SetCursorPosition = IBMramdac640SetCursorPosition;
infoPtr->LoadCursorImage = IBMramdac640LoadCursorImage;
infoPtr->HideCursor = IBMramdac640HideCursor;
infoPtr->ShowCursor = IBMramdac640ShowCursor;
infoPtr->UseHWCursor = IBMramdac640UseHWCursor;
}
Reference in New Issue View Git Blame Copy Permalink