#include "xf86.h"
#include "xf86_OSproc.h"
#include "xf86_ansic.h"
#include "xf86Version.h"
#include "mipointer.h"
#include "mibstore.h"
#include "micmap.h"
#include "fb.h"
#include "xf86cmap.h"
#include "tcx.h"
static const OptionInfoRec * TCXAvailableOptions(int chipid, int busid);
static void TCXIdentify(int flags);
static Bool TCXProbe(DriverPtr drv, int flags);
static Bool TCXPreInit(ScrnInfoPtr pScrn, int flags);
static Bool TCXScreenInit(int Index, ScreenPtr pScreen, int argc,
char **argv);
static Bool TCXEnterVT(int scrnIndex, int flags);
static void TCXLeaveVT(int scrnIndex, int flags);
static Bool TCXCloseScreen(int scrnIndex, ScreenPtr pScreen);
static Bool TCXSaveScreen(ScreenPtr pScreen, int mode);
static void TCXInitCplane24(ScrnInfoPtr pScrn);
static Bool TCXSwitchMode(int scrnIndex, DisplayModePtr mode, int flags);
static void TCXAdjustFrame(int scrnIndex, int x, int y, int flags);
static void TCXFreeScreen(int scrnIndex, int flags);
static ModeStatus TCXValidMode(int scrnIndex, DisplayModePtr mode,
Bool verbose, int flags);
void TCXSync(ScrnInfoPtr pScrn);
#define VERSION 4000
#define TCX_NAME "SUNTCX"
#define TCX_DRIVER_NAME "suntcx"
#define TCX_MAJOR_VERSION 1
#define TCX_MINOR_VERSION 0
#define TCX_PATCHLEVEL 0
DriverRec SUNTCX = {
VERSION,
TCX_DRIVER_NAME,
TCXIdentify,
TCXProbe,
TCXAvailableOptions,
NULL,
0
};
typedef enum {
OPTION_SW_CURSOR,
OPTION_HW_CURSOR
} TCXOpts;
static const OptionInfoRec TCXOptions[] = {
{ OPTION_SW_CURSOR, "SWcursor", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_HW_CURSOR, "HWcursor", OPTV_BOOLEAN, {0}, FALSE },
{ -1, NULL, OPTV_NONE, {0}, FALSE }
};
#ifdef XFree86LOADER
static MODULESETUPPROTO(tcxSetup);
static XF86ModuleVersionInfo suntcxVersRec =
{
"suntcx",
MODULEVENDORSTRING,
MODINFOSTRING1,
MODINFOSTRING2,
XF86_VERSION_CURRENT,
TCX_MAJOR_VERSION, TCX_MINOR_VERSION, TCX_PATCHLEVEL,
ABI_CLASS_VIDEODRV,
ABI_VIDEODRV_VERSION,
MOD_CLASS_VIDEODRV,
{0,0,0,0}
};
XF86ModuleData suntcxModuleData = { &suntcxVersRec, tcxSetup, NULL };
pointer
tcxSetup(pointer module, pointer opts, int *errmaj, int *errmin)
{
static Bool setupDone = FALSE;
if (!setupDone) {
setupDone = TRUE;
xf86AddDriver(&SUNTCX, module, 0);
return (pointer)TRUE;
} else {
if (errmaj) *errmaj = LDR_ONCEONLY;
return NULL;
}
}
#endif
static Bool
TCXGetRec(ScrnInfoPtr pScrn)
{
if (pScrn->driverPrivate != NULL)
return TRUE;
pScrn->driverPrivate = xnfcalloc(sizeof(TcxRec), 1);
return TRUE;
}
static void
TCXFreeRec(ScrnInfoPtr pScrn)
{
TcxPtr pTcx;
if (pScrn->driverPrivate == NULL)
return;
pTcx = GET_TCX_FROM_SCRN(pScrn);
xfree(pScrn->driverPrivate);
pScrn->driverPrivate = NULL;
return;
}
static const OptionInfoRec *
TCXAvailableOptions(int chipid, int busid)
{
return TCXOptions;
}
static void
TCXIdentify(int flags)
{
xf86Msg(X_INFO, "%s: driver for TCX\n", TCX_NAME);
}
static Bool
TCXProbe(DriverPtr drv, int flags)
{
int i;
GDevPtr *devSections;
int *usedChips;
int numDevSections;
int numUsed;
Bool foundScreen = FALSE;
EntityInfoPtr pEnt;
if ((numDevSections = xf86MatchDevice(TCX_DRIVER_NAME,
&devSections)) <= 0) {
return FALSE;
}
numUsed = xf86MatchSbusInstances(TCX_NAME, SBUS_DEVICE_TCX,
devSections, numDevSections,
drv, &usedChips);
xfree(devSections);
if (numUsed <= 0)
return FALSE;
if (flags & PROBE_DETECT)
foundScreen = TRUE;
else for (i = 0; i < numUsed; i++) {
pEnt = xf86GetEntityInfo(usedChips[i]);
if(pEnt->active) {
ScrnInfoPtr pScrn;
pScrn = xf86AllocateScreen(drv, 0);
pScrn->driverVersion = VERSION;
pScrn->driverName = TCX_DRIVER_NAME;
pScrn->name = TCX_NAME;
pScrn->Probe = TCXProbe;
pScrn->PreInit = TCXPreInit;
pScrn->ScreenInit = TCXScreenInit;
pScrn->SwitchMode = TCXSwitchMode;
pScrn->AdjustFrame = TCXAdjustFrame;
pScrn->EnterVT = TCXEnterVT;
pScrn->LeaveVT = TCXLeaveVT;
pScrn->FreeScreen = TCXFreeScreen;
pScrn->ValidMode = TCXValidMode;
xf86AddEntityToScreen(pScrn, pEnt->index);
foundScreen = TRUE;
}
xfree(pEnt);
}
xfree(usedChips);
return foundScreen;
}
static Bool
TCXPreInit(ScrnInfoPtr pScrn, int flags)
{
TcxPtr pTcx;
sbusDevicePtr psdp = NULL;
MessageType from;
int i;
int hwCursor, lowDepth;
if (flags & PROBE_DETECT) return FALSE;
if (!TCXGetRec(pScrn)) {
return FALSE;
}
pTcx = GET_TCX_FROM_SCRN(pScrn);
pScrn->monitor = pScrn->confScreen->monitor;
if (pScrn->numEntities > 1)
return FALSE;
for (i = 0; i < pScrn->numEntities; i++) {
EntityInfoPtr pEnt = xf86GetEntityInfo(pScrn->entityList[i]);
if (pEnt->location.type == BUS_SBUS) {
psdp = xf86GetSbusInfoForEntity(pEnt->index);
pTcx->psdp = psdp;
} else
return FALSE;
}
if (psdp == NULL)
return FALSE;
hwCursor = 0;
lowDepth = 1;
if (sparcPromInit() >= 0) {
hwCursor = sparcPromGetBool(&psdp->node, "hw-cursor");
lowDepth = sparcPromGetBool(&psdp->node, "tcx-8-bit");
sparcPromClose();
}
if (!xf86SetDepthBpp(pScrn, 0, 0, 0,
lowDepth ? NoDepth24Support : Support32bppFb)) {
return FALSE;
} else {
switch (pScrn->depth) {
case 8:
break;
case 32:
if (lowDepth) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"Given depth (32) not supported by hardware\n");
return FALSE;
}
break;
default:
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"Given depth (%d) is not supported by this driver\n",
pScrn->depth);
return FALSE;
}
}
xf86CollectOptions(pScrn, NULL);
if (!(pTcx->Options = xalloc(sizeof(TCXOptions))))
return FALSE;
memcpy(pTcx->Options, TCXOptions, sizeof(TCXOptions));
xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, pTcx->Options);
if (pScrn->depth > 8) {
rgb weight = {10, 11, 11};
rgb mask = {0xff, 0xff00, 0xff0000};
if (!xf86SetWeight(pScrn, weight, mask)) {
return FALSE;
}
}
if (!xf86SetDefaultVisual(pScrn, -1))
return FALSE;
else if (pScrn->depth > 8) {
if (pScrn->defaultVisual != TrueColor) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Given default visual"
" (%s) is not supported\n",
xf86GetVisualName(pScrn->defaultVisual));
return FALSE;
}
}
{
Gamma zeros = {0.0, 0.0, 0.0};
if (!xf86SetGamma(pScrn, zeros)) {
return FALSE;
}
}
from = X_PROBED;
pTcx->HWCursor = FALSE;
if (hwCursor) {
from = X_DEFAULT;
pTcx->HWCursor = TRUE;
if (xf86GetOptValBool(pTcx->Options, OPTION_HW_CURSOR, &pTcx->HWCursor))
from = X_CONFIG;
if (xf86ReturnOptValBool(pTcx->Options, OPTION_SW_CURSOR, FALSE)) {
from = X_CONFIG;
pTcx->HWCursor = FALSE;
}
}
xf86DrvMsg(pScrn->scrnIndex, from, "Using %s cursor\n",
pTcx->HWCursor ? "HW" : "SW");
if (xf86LoadSubModule(pScrn, "fb") == NULL) {
TCXFreeRec(pScrn);
return FALSE;
}
if (pTcx->HWCursor && xf86LoadSubModule(pScrn, "ramdac") == NULL) {
TCXFreeRec(pScrn);
return FALSE;
}
pScrn->progClock = TRUE;
if(pScrn->display->virtualX || pScrn->display->virtualY) {
xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
"TCX does not support a virtual desktop\n");
pScrn->display->virtualX = 0;
pScrn->display->virtualY = 0;
}
xf86SbusUseBuiltinMode(pScrn, pTcx->psdp);
pScrn->currentMode = pScrn->modes;
pScrn->displayWidth = pScrn->virtualX;
xf86SetDpi(pScrn, 0, 0);
return TRUE;
}
static Bool
TCXScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
{
ScrnInfoPtr pScrn;
TcxPtr pTcx;
VisualPtr visual;
int ret;
pScrn = xf86Screens[pScreen->myNum];
pTcx = GET_TCX_FROM_SCRN(pScrn);
if (pScrn->depth == 8)
pTcx->fb =
xf86MapSbusMem (pTcx->psdp, TCX_RAM8_VOFF,
(pTcx->psdp->width * pTcx->psdp->height));
else {
pTcx->fb =
xf86MapSbusMem (pTcx->psdp, TCX_RAM24_VOFF,
(pTcx->psdp->width * pTcx->psdp->height * 4));
pTcx->cplane =
xf86MapSbusMem (pTcx->psdp, TCX_CPLANE_VOFF,
(pTcx->psdp->width * pTcx->psdp->height * 4));
if (! pTcx->cplane)
return FALSE;
}
if (pTcx->HWCursor == TRUE) {
pTcx->thc = xf86MapSbusMem (pTcx->psdp, TCX_THC_VOFF, 8192);
if (! pTcx->thc)
return FALSE;
}
if (! pTcx->fb)
return FALSE;
TCXSaveScreen(pScreen, SCREEN_SAVER_ON);
miClearVisualTypes();
if (pScrn->depth == 8)
pScrn->rgbBits = 8;
if (!miSetVisualTypes(pScrn->depth,
pScrn->depth != 8 ? TrueColorMask :
miGetDefaultVisualMask(pScrn->depth),
pScrn->rgbBits, pScrn->defaultVisual))
return FALSE;
miSetPixmapDepths ();
if (pScrn->bitsPerPixel != 8)
TCXInitCplane24(pScrn);
ret = fbScreenInit(pScreen, pTcx->fb, pScrn->virtualX,
pScrn->virtualY, pScrn->xDpi, pScrn->yDpi,
pScrn->virtualX, pScrn->bitsPerPixel);
if (!ret)
return FALSE;
xf86SetBlackWhitePixels(pScreen);
if (pScrn->bitsPerPixel > 8) {
visual = pScreen->visuals + pScreen->numVisuals;
while (--visual >= pScreen->visuals) {
if ((visual->class | DynamicClass) == DirectColor) {
visual->offsetRed = pScrn->offset.red;
visual->offsetGreen = pScrn->offset.green;
visual->offsetBlue = pScrn->offset.blue;
visual->redMask = pScrn->mask.red;
visual->greenMask = pScrn->mask.green;
visual->blueMask = pScrn->mask.blue;
}
}
}
#ifdef RENDER
fbPictureInit (pScreen, 0, 0);
#endif
miInitializeBackingStore(pScreen);
xf86SetBackingStore(pScreen);
xf86SetSilkenMouse(pScreen);
miDCInitialize (pScreen, xf86GetPointerScreenFuncs());
if (pTcx->HWCursor) {
extern Bool TCXHWCursorInit(ScreenPtr pScreen);
if(!TCXHWCursorInit(pScreen)) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"Hardware cursor initialization failed\n");
return(FALSE);
}
xf86SbusHideOsHwCursor(pTcx->psdp);
}
if (!miCreateDefColormap(pScreen))
return FALSE;
if(pScrn->depth == 8 && !xf86SbusHandleColormaps(pScreen, pTcx->psdp))
return FALSE;
pTcx->CloseScreen = pScreen->CloseScreen;
pScreen->CloseScreen = TCXCloseScreen;
pScreen->SaveScreen = TCXSaveScreen;
if (serverGeneration == 1) {
xf86ShowUnusedOptions(pScrn->scrnIndex, pScrn->options);
}
TCXSaveScreen(pScreen, SCREEN_SAVER_OFF);
return TRUE;
}
static Bool
TCXSwitchMode(int scrnIndex, DisplayModePtr mode, int flags)
{
return TRUE;
}
static void
TCXAdjustFrame(int scrnIndex, int x, int y, int flags)
{
return;
}
static Bool
TCXEnterVT(int scrnIndex, int flags)
{
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
TcxPtr pTcx = GET_TCX_FROM_SCRN(pScrn);
if (pTcx->HWCursor) {
xf86SbusHideOsHwCursor (pTcx->psdp);
pTcx->CursorFg = 0;
pTcx->CursorBg = 0;
}
if (pTcx->cplane) {
TCXInitCplane24 (pScrn);
}
return TRUE;
}
static void
TCXLeaveVT(int scrnIndex, int flags)
{
return;
}
static Bool
TCXCloseScreen(int scrnIndex, ScreenPtr pScreen)
{
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
TcxPtr pTcx = GET_TCX_FROM_SCRN(pScrn);
pScrn->vtSema = FALSE;
if (pScrn->depth == 8)
xf86UnmapSbusMem(pTcx->psdp, pTcx->fb,
(pTcx->psdp->width * pTcx->psdp->height));
else {
xf86UnmapSbusMem(pTcx->psdp, pTcx->fb,
(pTcx->psdp->width * pTcx->psdp->height * 4));
xf86UnmapSbusMem(pTcx->psdp, pTcx->cplane,
(pTcx->psdp->width * pTcx->psdp->height * 4));
}
if (pTcx->thc)
xf86UnmapSbusMem(pTcx->psdp, pTcx->fb, 8192);
if (pTcx->HWCursor)
xf86SbusHideOsHwCursor (pTcx->psdp);
pScreen->CloseScreen = pTcx->CloseScreen;
return (*pScreen->CloseScreen)(scrnIndex, pScreen);
return FALSE;
}
static void
TCXFreeScreen(int scrnIndex, int flags)
{
TCXFreeRec(xf86Screens[scrnIndex]);
}
static ModeStatus
TCXValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags)
{
if (mode->Flags & V_INTERLACE)
return(MODE_BAD);
return(MODE_OK);
}
static Bool
TCXSaveScreen(ScreenPtr pScreen, int mode)
{
return TRUE;
}
void
TCXSync(ScrnInfoPtr pScrn)
{
return;
}
static void
TCXInitCplane24(ScrnInfoPtr pScrn)
{
TcxPtr pTcx = GET_TCX_FROM_SCRN(pScrn);
int size;
unsigned int *p, *q;
if (!pTcx->cplane)
return;
size = pScrn->virtualX * pScrn->virtualY;
memset (pTcx->fb, 0, size * 4);
p = pTcx->cplane;
for (q = pTcx->cplane + size; p != q; p++)
*p = (*p & 0xffffff) | TCX_CPLANE_MODE;
}