wsfb_driver.c revision 2b2b17b3 
1/* $OpenBSD: wsfb_driver.c,v 1.19 2003/04/27 16:42:32 matthieu Exp $ */
2/*
3 * Copyright (c) 2001 Matthieu Herrb
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 *    - Redistributions of source code must retain the above copyright
11 *      notice, this list of conditions and the following disclaimer.
12 *    - Redistributions in binary form must reproduce the above
13 *      copyright notice, this list of conditions and the following
14 *      disclaimer in the documentation and/or other materials provided
15 *      with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
20 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
21 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
23 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
25 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
27 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28 * POSSIBILITY OF SUCH DAMAGE.
29 *
30 */
31
32/*
33 * Based on fbdev.c written by:
34 *
35 * Authors:  Alan Hourihane, <alanh@fairlite.demon.co.uk>
36 *	     Michel Dänzer, <michdaen@iiic.ethz.ch>
37 */
38
39#ifdef HAVE_CONFIG_H
40#include "config.h"
41#endif
42
43#include <fcntl.h>
44#include <sys/types.h>
45#include <sys/time.h>
46#include <errno.h>
47#include <dev/wscons/wsconsio.h>
48
49/* all driver need this */
50#include "xf86.h"
51#include "xf86_OSproc.h"
52
53#include "mipointer.h"
54#include "mibstore.h"
55#include "micmap.h"
56#include "colormapst.h"
57#include "xf86cmap.h"
58#include "shadow.h"
59#include "dgaproc.h"
60
61/* for visuals */
62#include "fb.h"
63
64#include "xf86Resources.h"
65#include "xf86RAC.h"
66
67#ifdef XvExtension
68#include "xf86xv.h"
69#endif
70
71#include "wsfb.h"
72
73/* #include "wsconsio.h" */
74
75#include <sys/mman.h>
76
77#ifdef USE_PRIVSEP
78extern int priv_open_device(const char *);
79#else
80#define priv_open_device(n)    open(n,O_RDWR|O_NONBLOCK|O_EXCL)
81#endif
82
83#if defined(__NetBSD__)
84#define WSFB_DEFAULT_DEV "/dev/ttyE0"
85#else
86#define WSFB_DEFAULT_DEV "/dev/ttyC0"
87#endif
88
89#define DEBUG 0
90
91#if DEBUG
92# define TRACE_ENTER(str)       ErrorF("wsfb: " str " %d\n",pScrn->scrnIndex)
93# define TRACE_EXIT(str)        ErrorF("wsfb: " str " done\n")
94# define TRACE(str)             ErrorF("wsfb trace: " str "\n")
95#else
96# define TRACE_ENTER(str)
97# define TRACE_EXIT(str)
98# define TRACE(str)
99#endif
100
101/* Prototypes */
102#ifdef XFree86LOADER
103static pointer WsfbSetup(pointer, pointer, int *, int *);
104#endif
105static Bool WsfbGetRec(ScrnInfoPtr);
106static void WsfbFreeRec(ScrnInfoPtr);
107static const OptionInfoRec * WsfbAvailableOptions(int, int);
108static void WsfbIdentify(int);
109static Bool WsfbProbe(DriverPtr, int);
110static Bool WsfbPreInit(ScrnInfoPtr, int);
111static Bool WsfbScreenInit(int, ScreenPtr, int, char **);
112static Bool WsfbCloseScreen(int, ScreenPtr);
113static void *WsfbWindowLinear(ScreenPtr, CARD32, CARD32, int, CARD32 *,
114			      void *);
115static void WsfbPointerMoved(int, int, int);
116static Bool WsfbEnterVT(int, int);
117static void WsfbLeaveVT(int, int);
118static Bool WsfbSwitchMode(int, DisplayModePtr, int);
119static int WsfbValidMode(int, DisplayModePtr, Bool, int);
120static void WsfbLoadPalette(ScrnInfoPtr, int, int *, LOCO *, VisualPtr);
121static Bool WsfbSaveScreen(ScreenPtr, int);
122static void WsfbSave(ScrnInfoPtr);
123static void WsfbRestore(ScrnInfoPtr);
124
125/* dga stuff */
126#ifdef XFreeXDGA
127static Bool WsfbDGAOpenFramebuffer(ScrnInfoPtr, char **, unsigned char **,
128				   int *, int *, int *);
129static Bool WsfbDGASetMode(ScrnInfoPtr, DGAModePtr);
130static void WsfbDGASetViewport(ScrnInfoPtr, int, int, int);
131static Bool WsfbDGAInit(ScrnInfoPtr, ScreenPtr);
132#endif
133static Bool WsfbDriverFunc(ScrnInfoPtr pScrn, xorgDriverFuncOp op,
134				pointer ptr);
135
136/* helper functions */
137static int wsfb_open(char *);
138static pointer wsfb_mmap(size_t, off_t, int);
139
140enum { WSFB_ROTATE_NONE = 0,
141       WSFB_ROTATE_CCW = 90,
142       WSFB_ROTATE_UD = 180,
143       WSFB_ROTATE_CW = 270
144};
145
146/*
147 * This is intentionally screen-independent.  It indicates the binding
148 * choice made in the first PreInit.
149 */
150static int pix24bpp = 0;
151
152#define WSFB_VERSION 		4000
153#define WSFB_NAME		"wsfb"
154#define WSFB_DRIVER_NAME	"wsfb"
155
156_X_EXPORT DriverRec WSFB = {
157	WSFB_VERSION,
158	WSFB_DRIVER_NAME,
159	WsfbIdentify,
160	WsfbProbe,
161	WsfbAvailableOptions,
162	NULL,
163	0,
164	WsfbDriverFunc
165};
166
167/* Supported "chipsets" */
168static SymTabRec WsfbChipsets[] = {
169	{ 0, "wsfb" },
170	{ -1, NULL }
171};
172
173/* Supported options */
174typedef enum {
175	OPTION_SHADOW_FB,
176	OPTION_ROTATE,
177	OPTION_HW_CURSOR,
178	OPTION_SW_CURSOR
179} WsfbOpts;
180
181static const OptionInfoRec WsfbOptions[] = {
182	{ OPTION_SHADOW_FB, "ShadowFB", OPTV_BOOLEAN, {0}, FALSE},
183	{ OPTION_ROTATE, "Rotate", OPTV_STRING, {0}, FALSE},
184	{ -1, NULL, OPTV_NONE, {0}, FALSE}
185};
186
187/* Symbols needed from other modules */
188static const char *fbSymbols[] = {
189	"fbPictureInit",
190	"fbScreenInit",
191	NULL
192};
193static const char *shadowSymbols[] = {
194	"shadowAdd",
195	"shadowSetup",
196	"shadowUpdatePacked",
197	"shadowUpdatePackedWeak",
198	"shadowUpdateRotatePacked",
199	"shadowUpdateRotatePackedWeak",
200	NULL
201};
202
203static const char *ramdacSymbols[] = {
204	"xf86CreateCursorInfoRec",
205	"xf86DestroyCursorInfoRec",
206	"xf86InitCursor",
207	NULL
208};
209
210#ifdef XFree86LOADER
211static XF86ModuleVersionInfo WsfbVersRec = {
212	"wsfb",
213	MODULEVENDORSTRING,
214	MODINFOSTRING1,
215	MODINFOSTRING2,
216	XORG_VERSION_CURRENT,
217	PACKAGE_VERSION_MAJOR,
218	PACKAGE_VERSION_MINOR,
219	PACKAGE_VERSION_PATCHLEVEL,
220	ABI_CLASS_VIDEODRV,
221	ABI_VIDEODRV_VERSION,
222	NULL,
223	{0, 0, 0, 0}
224};
225
226_X_EXPORT XF86ModuleData wsfbModuleData = { &WsfbVersRec, WsfbSetup, NULL };
227
228static pointer
229WsfbSetup(pointer module, pointer opts, int *errmaj, int *errmin)
230{
231	static Bool setupDone = FALSE;
232	const char *osname;
233
234	/* Check that we're being loaded on a OpenBSD or NetBSD system */
235	LoaderGetOS(&osname, NULL, NULL, NULL);
236	if (!osname || (strcmp(osname, "openbsd") != 0 &&
237	                strcmp(osname, "netbsd") != 0)) {
238		if (errmaj)
239			*errmaj = LDR_BADOS;
240		if (errmin)
241			*errmin = 0;
242		return NULL;
243	}
244	if (!setupDone) {
245		setupDone = TRUE;
246		xf86AddDriver(&WSFB, module, HaveDriverFuncs);
247		LoaderRefSymLists(fbSymbols, shadowSymbols, ramdacSymbols,
248		    NULL);
249		return (pointer)1;
250	} else {
251		if (errmaj != NULL)
252			*errmaj = LDR_ONCEONLY;
253		return NULL;
254	}
255}
256#endif /* XFree86LOADER */
257
258static Bool
259WsfbGetRec(ScrnInfoPtr pScrn)
260{
261
262	if (pScrn->driverPrivate != NULL)
263		return TRUE;
264
265	pScrn->driverPrivate = xnfcalloc(sizeof(WsfbRec), 1);
266	return TRUE;
267}
268
269static void
270WsfbFreeRec(ScrnInfoPtr pScrn)
271{
272
273	if (pScrn->driverPrivate == NULL)
274		return;
275	xfree(pScrn->driverPrivate);
276	pScrn->driverPrivate = NULL;
277}
278
279static const OptionInfoRec *
280WsfbAvailableOptions(int chipid, int busid)
281{
282	return WsfbOptions;
283}
284
285static void
286WsfbIdentify(int flags)
287{
288	xf86PrintChipsets(WSFB_NAME, "driver for wsdisplay framebuffer",
289			  WsfbChipsets);
290}
291
292/* Open the framebuffer device */
293static int
294wsfb_open(char *dev)
295{
296	int fd = -1;
297
298	/* try argument from XF86Config first */
299	if (dev == NULL || ((fd = priv_open_device(dev)) == -1)) {
300		/* second: environment variable */
301		dev = getenv("XDEVICE");
302		if (dev == NULL || ((fd = priv_open_device(dev)) == -1)) {
303			/* last try: default device */
304			dev = WSFB_DEFAULT_DEV;
305			if ((fd = priv_open_device(dev)) == -1) {
306				return -1;
307			}
308		}
309	}
310	return fd;
311}
312
313/* Map the framebuffer's memory */
314static pointer
315wsfb_mmap(size_t len, off_t off, int fd)
316{
317	int pagemask, mapsize;
318	caddr_t addr;
319	pointer mapaddr;
320
321	pagemask = getpagesize() - 1;
322	mapsize = ((int) len + pagemask) & ~pagemask;
323	addr = 0;
324
325	/*
326	 * try and make it private first, that way once we get it, an
327	 * interloper, e.g. another server, can't get this frame buffer,
328	 * and if another server already has it, this one won't.
329	 */
330	mapaddr = (pointer) mmap(addr, mapsize,
331				 PROT_READ | PROT_WRITE, MAP_SHARED,
332				 fd, off);
333	if (mapaddr == MAP_FAILED) {
334		mapaddr = NULL;
335	}
336#if DEBUG
337	ErrorF("mmap returns: addr %p len 0x%x\n", mapaddr, mapsize);
338#endif
339	return mapaddr;
340}
341
342static Bool
343WsfbProbe(DriverPtr drv, int flags)
344{
345	int i, fd, entity;
346       	GDevPtr *devSections;
347	int numDevSections;
348	char *dev;
349	Bool foundScreen = FALSE;
350
351	TRACE("probe start");
352
353	/* For now, just bail out for PROBE_DETECT. */
354	if (flags & PROBE_DETECT)
355		return FALSE;
356
357	if ((numDevSections = xf86MatchDevice(WSFB_DRIVER_NAME,
358					      &devSections)) <= 0)
359		return FALSE;
360
361	for (i = 0; i < numDevSections; i++) {
362		ScrnInfoPtr pScrn = NULL;
363
364		dev = xf86FindOptionValue(devSections[i]->options, "device");
365		if ((fd = wsfb_open(dev)) >= 0) {
366			entity = xf86ClaimFbSlot(drv, 0, devSections[i], TRUE);
367			pScrn = xf86ConfigFbEntity(NULL,0,entity,
368						   NULL,NULL,NULL,NULL);
369			if (pScrn != NULL) {
370				foundScreen = TRUE;
371				pScrn->driverVersion = WSFB_VERSION;
372				pScrn->driverName = WSFB_DRIVER_NAME;
373				pScrn->name = WSFB_NAME;
374				pScrn->Probe = WsfbProbe;
375				pScrn->PreInit = WsfbPreInit;
376				pScrn->ScreenInit = WsfbScreenInit;
377				pScrn->SwitchMode = WsfbSwitchMode;
378				pScrn->AdjustFrame = NULL;
379				pScrn->EnterVT = WsfbEnterVT;
380				pScrn->LeaveVT = WsfbLeaveVT;
381				pScrn->ValidMode = WsfbValidMode;
382
383				xf86DrvMsg(pScrn->scrnIndex, X_INFO,
384				    "using %s\n", dev != NULL ? dev :
385				    "default device");
386			}
387		}
388	}
389	xfree(devSections);
390	TRACE("probe done");
391	return foundScreen;
392}
393
394static Bool
395WsfbPreInit(ScrnInfoPtr pScrn, int flags)
396{
397	WsfbPtr fPtr;
398	int default_depth, wstype;
399	char *dev, *s;
400	char *mod = NULL;
401	const char *reqSym = NULL;
402	Gamma zeros = {0.0, 0.0, 0.0};
403	DisplayModePtr mode;
404	MessageType from;
405
406	if (flags & PROBE_DETECT) return FALSE;
407
408	TRACE_ENTER("PreInit");
409
410	if (pScrn->numEntities != 1) return FALSE;
411
412	pScrn->monitor = pScrn->confScreen->monitor;
413
414	WsfbGetRec(pScrn);
415	fPtr = WSFBPTR(pScrn);
416
417	fPtr->pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
418
419	pScrn->racMemFlags = RAC_FB | RAC_COLORMAP | RAC_CURSOR | RAC_VIEWPORT;
420	pScrn->racIoFlags = pScrn->racMemFlags;
421
422	dev = xf86FindOptionValue(fPtr->pEnt->device->options, "device");
423	fPtr->fd = wsfb_open(dev);
424	if (fPtr->fd == -1) {
425		return FALSE;
426	}
427
428	if (ioctl(fPtr->fd, WSDISPLAYIO_GINFO, &fPtr->info) == -1) {
429		xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
430			   "ioctl WSDISPLAY_GINFO: %s\n",
431			   strerror(errno));
432		return FALSE;
433	}
434	if (ioctl(fPtr->fd, WSDISPLAYIO_GTYPE, &wstype) == -1) {
435		xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
436			   "ioctl WSDISPLAY_GTYPE: %s\n",
437			   strerror(errno));
438		return FALSE;
439	}
440	if (ioctl(fPtr->fd, WSDISPLAYIO_LINEBYTES, &fPtr->linebytes) == -1) {
441		xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
442			   "ioctl WSDISPLAYIO_LINEBYTES: %s\n",
443			   strerror(errno));
444		return FALSE;
445	}
446	/*
447	 * Allocate room for saving the colormap
448	 */
449	if (fPtr->info.cmsize != 0) {
450		fPtr->saved_cmap.red =
451		    (unsigned char *)xalloc(fPtr->info.cmsize);
452		if (fPtr->saved_cmap.red == NULL) {
453			xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
454			    "Cannot malloc %d bytes\n", fPtr->info.cmsize);
455			return FALSE;
456		}
457		fPtr->saved_cmap.green =
458		    (unsigned char *)xalloc(fPtr->info.cmsize);
459		if (fPtr->saved_cmap.green == NULL) {
460			xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
461			    "Cannot malloc %d bytes\n", fPtr->info.cmsize);
462			xfree(fPtr->saved_cmap.red);
463			return FALSE;
464		}
465		fPtr->saved_cmap.blue =
466		    (unsigned char *)xalloc(fPtr->info.cmsize);
467		if (fPtr->saved_cmap.blue == NULL) {
468			xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
469			    "Cannot malloc %d bytes\n", fPtr->info.cmsize);
470			xfree(fPtr->saved_cmap.red);
471			xfree(fPtr->saved_cmap.green);
472			return FALSE;
473		}
474	}
475
476	/* Handle depth */
477	default_depth = fPtr->info.depth <= 24 ? fPtr->info.depth : 24;
478	if (!xf86SetDepthBpp(pScrn, default_depth, default_depth,
479		fPtr->info.depth,
480		fPtr->info.depth >= 24 ? Support24bppFb|Support32bppFb : 0))
481		return FALSE;
482
483	/* Check consistency */
484	if (pScrn->bitsPerPixel != fPtr->info.depth) {
485		xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
486		    "specified depth (%d) or bpp (%d) doesn't match "
487		    "framebuffer depth (%d)\n", pScrn->depth,
488		    pScrn->bitsPerPixel, fPtr->info.depth);
489		return FALSE;
490	}
491	xf86PrintDepthBpp(pScrn);
492
493	/* Get the depth24 pixmap format */
494	if (pScrn->depth == 24 && pix24bpp == 0)
495		pix24bpp = xf86GetBppFromDepth(pScrn, 24);
496
497	/* color weight */
498	if (pScrn->depth > 8) {
499		rgb zeros = { 0, 0, 0 }, masks;
500
501		if (wstype == WSDISPLAY_TYPE_SUN24 ||
502		    wstype == WSDISPLAY_TYPE_SUNCG12 ||
503		    wstype == WSDISPLAY_TYPE_SUNCG14 ||
504		    wstype == WSDISPLAY_TYPE_SUNTCX ||
505		    wstype == WSDISPLAY_TYPE_SUNFFB) {
506			masks.red = 0x0000ff;
507			masks.green = 0x00ff00;
508			masks.blue = 0xff0000;
509		} else {
510			masks.red = 0;
511			masks.green = 0;
512			masks.blue = 0;
513		}
514
515		if (!xf86SetWeight(pScrn, zeros, masks))
516			return FALSE;
517	}
518
519	/* visual init */
520	if (!xf86SetDefaultVisual(pScrn, -1))
521		return FALSE;
522
523	/* We don't currently support DirectColor at > 8bpp */
524	if (pScrn->depth > 8 && pScrn->defaultVisual != TrueColor) {
525		xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Given default visual"
526			   " (%s) is not supported at depth %d\n",
527			   xf86GetVisualName(pScrn->defaultVisual),
528			   pScrn->depth);
529		return FALSE;
530	}
531
532	xf86SetGamma(pScrn,zeros);
533
534	pScrn->progClock = TRUE;
535	pScrn->rgbBits   = 8;
536	pScrn->chipset   = "wsfb";
537	pScrn->videoRam  = fPtr->linebytes * fPtr->info.height;
538
539	xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Vidmem: %dk\n",
540		   pScrn->videoRam/1024);
541
542	/* handle options */
543	xf86CollectOptions(pScrn, NULL);
544	if (!(fPtr->Options = xalloc(sizeof(WsfbOptions))))
545		return FALSE;
546	memcpy(fPtr->Options, WsfbOptions, sizeof(WsfbOptions));
547	xf86ProcessOptions(pScrn->scrnIndex, fPtr->pEnt->device->options,
548			   fPtr->Options);
549
550	/* use shadow framebuffer by default, on depth >= 8 */
551	if (pScrn->depth >= 8)
552		fPtr->shadowFB = xf86ReturnOptValBool(fPtr->Options,
553						      OPTION_SHADOW_FB, TRUE);
554	else
555		if (xf86ReturnOptValBool(fPtr->Options,
556					 OPTION_SHADOW_FB, FALSE)) {
557			xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
558				   "Shadow FB option ignored on depth < 8");
559		}
560
561	/* rotation */
562	fPtr->rotate = WSFB_ROTATE_NONE;
563	if ((s = xf86GetOptValString(fPtr->Options, OPTION_ROTATE))) {
564		if (pScrn->depth >= 8) {
565			if (!xf86NameCmp(s, "CW")) {
566				fPtr->shadowFB = TRUE;
567				fPtr->rotate = WSFB_ROTATE_CW;
568				xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
569				    "Rotating screen clockwise\n");
570			} else if (!xf86NameCmp(s, "CCW")) {
571				fPtr->shadowFB = TRUE;
572				fPtr->rotate = WSFB_ROTATE_CCW;
573				xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
574				    "Rotating screen counter clockwise\n");
575			} else if (!xf86NameCmp(s, "UD")) {
576				fPtr->shadowFB = TRUE;
577				fPtr->rotate = WSFB_ROTATE_UD;
578				xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
579				    "Rotating screen upside down\n");
580			} else {
581				xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
582				    "\"%s\" is not a valid value for Option "
583				    "\"Rotate\"\n", s);
584				xf86DrvMsg(pScrn->scrnIndex, X_INFO,
585				    "Valid options are \"CW\", \"CCW\","
586				    " or \"UD\"\n");
587			}
588		} else {
589			xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
590			    "Option \"Rotate\" ignored on depth < 8");
591		}
592	}
593
594	/* fake video mode struct */
595	mode = (DisplayModePtr)xalloc(sizeof(DisplayModeRec));
596	mode->prev = mode;
597	mode->next = mode;
598	mode->name = "wsfb current mode";
599	mode->status = MODE_OK;
600	mode->type = M_T_BUILTIN;
601	mode->Clock = 0;
602	mode->HDisplay = fPtr->info.width;
603	mode->HSyncStart = 0;
604	mode->HSyncEnd = 0;
605	mode->HTotal = 0;
606	mode->HSkew = 0;
607	mode->VDisplay = fPtr->info.height;
608	mode->VSyncStart = 0;
609	mode->VSyncEnd = 0;
610	mode->VTotal = 0;
611	mode->VScan = 0;
612	mode->Flags = 0;
613	if (pScrn->modes != NULL) {
614		xf86DrvMsg(pScrn->scrnIndex, X_INFO,
615		   "Ignoring mode specification from screen section\n");
616	}
617	pScrn->currentMode = pScrn->modes = mode;
618	pScrn->virtualX = fPtr->info.width;
619	pScrn->virtualY = fPtr->info.height;
620	pScrn->displayWidth = pScrn->virtualX;
621
622	/* Set the display resolution */
623	xf86SetDpi(pScrn, 0, 0);
624
625	from = X_DEFAULT;
626	fPtr->HWCursor = TRUE;
627	if (xf86GetOptValBool(fPtr->Options, OPTION_HW_CURSOR, &fPtr->HWCursor))
628		from = X_CONFIG;
629	if (xf86ReturnOptValBool(fPtr->Options, OPTION_SW_CURSOR, FALSE)) {
630		from = X_CONFIG;
631		fPtr->HWCursor = FALSE;
632	}
633	xf86DrvMsg(pScrn->scrnIndex, from, "Using %s cursor\n",
634		fPtr->HWCursor ? "HW" : "SW");
635
636	/* Load bpp-specific modules */
637	switch(pScrn->bitsPerPixel) {
638	default:
639		mod = "fb";
640		break;
641	}
642
643
644	/* Load shadow if needed */
645	if (fPtr->shadowFB) {
646		xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
647			   "Using \"Shadow Framebuffer\"\n");
648		if (xf86LoadSubModule(pScrn, "shadow") == NULL) {
649			WsfbFreeRec(pScrn);
650			return FALSE;
651		}
652		xf86LoaderReqSymLists(shadowSymbols, NULL);
653	}
654
655	if (mod && xf86LoadSubModule(pScrn, mod) == NULL) {
656		WsfbFreeRec(pScrn);
657		return FALSE;
658	}
659
660	if (xf86LoadSubModule(pScrn, "ramdac") == NULL) {
661		WsfbFreeRec(pScrn);
662		return FALSE;
663        }
664
665	if (mod) {
666		if (reqSym) {
667			xf86LoaderReqSymbols(reqSym, NULL);
668		} else {
669			xf86LoaderReqSymLists(fbSymbols, NULL);
670		}
671	}
672	TRACE_EXIT("PreInit");
673	return TRUE;
674}
675
676static Bool
677WsfbCreateScreenResources(ScreenPtr pScreen)
678{
679	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
680	WsfbPtr fPtr = WSFBPTR(pScrn);
681	PixmapPtr pPixmap;
682	Bool ret;
683
684	pScreen->CreateScreenResources = fPtr->CreateScreenResources;
685	ret = pScreen->CreateScreenResources(pScreen);
686	pScreen->CreateScreenResources = WsfbCreateScreenResources;
687
688	if (!ret)
689		return FALSE;
690
691	pPixmap = pScreen->GetScreenPixmap(pScreen);
692
693	if (!shadowAdd(pScreen, pPixmap, fPtr->rotate ?
694		shadowUpdateRotatePackedWeak() : shadowUpdatePackedWeak(),
695		WsfbWindowLinear, fPtr->rotate, NULL)) {
696		return FALSE;
697	}
698	return TRUE;
699}
700
701
702static Bool
703WsfbShadowInit(ScreenPtr pScreen)
704{
705	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
706	WsfbPtr fPtr = WSFBPTR(pScrn);
707
708	if (!shadowSetup(pScreen))
709		return FALSE;
710	fPtr->CreateScreenResources = pScreen->CreateScreenResources;
711	pScreen->CreateScreenResources = WsfbCreateScreenResources;
712
713	return TRUE;
714}
715
716static Bool
717WsfbScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
718{
719	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
720	WsfbPtr fPtr = WSFBPTR(pScrn);
721	VisualPtr visual;
722	int ret, flags, ncolors;
723	int wsmode = WSDISPLAYIO_MODE_DUMBFB;
724	size_t len;
725
726	TRACE_ENTER("WsfbScreenInit");
727#if DEBUG
728	ErrorF("\tbitsPerPixel=%d, depth=%d, defaultVisual=%s\n"
729	       "\tmask: %x,%x,%x, offset: %u,%u,%u\n",
730	       pScrn->bitsPerPixel,
731	       pScrn->depth,
732	       xf86GetVisualName(pScrn->defaultVisual),
733	       pScrn->mask.red,pScrn->mask.green,pScrn->mask.blue,
734	       pScrn->offset.red,pScrn->offset.green,pScrn->offset.blue);
735#endif
736	switch (fPtr->info.depth) {
737	case 1:
738	case 4:
739	case 8:
740		len = fPtr->linebytes*fPtr->info.height;
741		break;
742	case 16:
743		if (fPtr->linebytes == fPtr->info.width) {
744			len = fPtr->info.width*fPtr->info.height*sizeof(short);
745		} else {
746			len = fPtr->linebytes*fPtr->info.height;
747		}
748		break;
749	case 24:
750		if (fPtr->linebytes == fPtr->info.width) {
751			len = fPtr->info.width*fPtr->info.height*3;
752		} else {
753			len = fPtr->linebytes*fPtr->info.height;
754		}
755		break;
756	case 32:
757		if (fPtr->linebytes == fPtr->info.width) {
758			len = fPtr->info.width*fPtr->info.height*sizeof(int);
759		} else {
760			len = fPtr->linebytes*fPtr->info.height;
761		}
762		break;
763	default:
764		xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
765			   "unsupported depth %d\n", fPtr->info.depth);
766		return FALSE;
767	}
768	/* Switch to graphics mode - required before mmap */
769	if (ioctl(fPtr->fd, WSDISPLAYIO_SMODE, &wsmode) == -1) {
770		xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
771			   "ioctl WSDISPLAYIO_SMODE: %s\n",
772			   strerror(errno));
773		return FALSE;
774	}
775	fPtr->fbmem = wsfb_mmap(len, 0, fPtr->fd);
776
777	if (fPtr->fbmem == NULL) {
778		xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
779			   "wsfb_mmap: %s\n", strerror(errno));
780		return FALSE;
781	}
782	fPtr->fbmem_len = len;
783
784	WsfbSave(pScrn);
785	pScrn->vtSema = TRUE;
786
787	/* mi layer */
788	miClearVisualTypes();
789	if (pScrn->bitsPerPixel > 8) {
790		if (!miSetVisualTypes(pScrn->depth, TrueColorMask,
791				      pScrn->rgbBits, TrueColor))
792			return FALSE;
793	} else {
794		if (!miSetVisualTypes(pScrn->depth,
795				      miGetDefaultVisualMask(pScrn->depth),
796				      pScrn->rgbBits, pScrn->defaultVisual))
797			return FALSE;
798	}
799	if (!miSetPixmapDepths())
800		return FALSE;
801
802	if (fPtr->rotate == WSFB_ROTATE_CW
803	    || fPtr->rotate == WSFB_ROTATE_CCW) {
804		int tmp = pScrn->virtualX;
805		pScrn->virtualX = pScrn->displayWidth = pScrn->virtualY;
806		pScrn->virtualY = tmp;
807	}
808	if (fPtr->rotate && !fPtr->PointerMoved) {
809		fPtr->PointerMoved = pScrn->PointerMoved;
810		pScrn->PointerMoved = WsfbPointerMoved;
811	}
812
813	fPtr->fbstart = fPtr->fbmem;
814
815	switch (pScrn->bitsPerPixel) {
816	case 8:
817	case 16:
818	case 24:
819	case 32:
820		ret = fbScreenInit(pScreen,
821		    /*fPtr->shadowFB ? fPtr->shadow :*/ fPtr->fbstart,
822		    pScrn->virtualX, pScrn->virtualY,
823		    pScrn->xDpi, pScrn->yDpi,
824		    pScrn->displayWidth, pScrn->bitsPerPixel);
825		break;
826	default:
827		xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
828			   "Unsupported bpp: %d", pScrn->bitsPerPixel);
829		return FALSE;
830	} /* case */
831
832	if (!ret)
833		return FALSE;
834
835	if (pScrn->bitsPerPixel > 8) {
836		/* Fixup RGB ordering */
837		visual = pScreen->visuals + pScreen->numVisuals;
838		while (--visual >= pScreen->visuals) {
839			if ((visual->class | DynamicClass) == DirectColor) {
840				visual->offsetRed   = pScrn->offset.red;
841				visual->offsetGreen = pScrn->offset.green;
842				visual->offsetBlue  = pScrn->offset.blue;
843				visual->redMask     = pScrn->mask.red;
844				visual->greenMask   = pScrn->mask.green;
845				visual->blueMask    = pScrn->mask.blue;
846			}
847		}
848	}
849
850	if (pScrn->bitsPerPixel >= 8) {
851		if (!fbPictureInit(pScreen, NULL, 0))
852			xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
853				   "RENDER extension initialisation failed.");
854	}
855	if (fPtr->shadowFB && !WsfbShadowInit(pScreen)) {
856		xf86DrvMsg(scrnIndex, X_ERROR,
857		    "shadow framebuffer initialization failed\n");
858		return FALSE;
859	}
860
861#ifdef XFreeXDGA
862	if (!fPtr->rotate)
863		WsfbDGAInit(pScrn, pScreen);
864	else
865		xf86DrvMsg(scrnIndex, X_INFO, "Rotated display, "
866		    "disabling DGA\n");
867#endif
868	if (fPtr->rotate) {
869		xf86DrvMsg(scrnIndex, X_INFO, "Enabling Driver Rotation, "
870		    "disabling RandR\n");
871		xf86DisableRandR();
872		if (pScrn->bitsPerPixel == 24)
873			xf86DrvMsg(scrnIndex, X_WARNING,
874			    "Rotation might be broken in 24 bpp\n");
875	}
876
877	xf86SetBlackWhitePixels(pScreen);
878	miInitializeBackingStore(pScreen);
879	xf86SetBackingStore(pScreen);
880
881	/* software cursor */
882	miDCInitialize(pScreen, xf86GetPointerScreenFuncs());
883
884	/* check for hardware cursor support */
885	if (fPtr->HWCursor)
886		WsfbSetupCursor(pScreen);
887
888	/* colormap */
889	if (!miCreateDefColormap(pScreen))
890		return FALSE;
891	flags = CMAP_RELOAD_ON_MODE_SWITCH;
892	ncolors = fPtr->info.cmsize;
893	/* on StaticGray visuals, fake a 256 entries colormap */
894	if (ncolors == 0)
895		ncolors = 256;
896	if(!xf86HandleColormaps(pScreen, ncolors, 8, WsfbLoadPalette,
897				NULL, flags))
898		return FALSE;
899
900	pScreen->SaveScreen = WsfbSaveScreen;
901
902#ifdef XvExtension
903	{
904		XF86VideoAdaptorPtr *ptr;
905
906		int n = xf86XVListGenericAdaptors(pScrn,&ptr);
907		if (n) {
908			xf86XVScreenInit(pScreen,ptr,n);
909		}
910	}
911#endif
912
913	/* Wrap the current CloseScreen function */
914	fPtr->CloseScreen = pScreen->CloseScreen;
915	pScreen->CloseScreen = WsfbCloseScreen;
916
917	TRACE_EXIT("WsfbScreenInit");
918	return TRUE;
919}
920
921static Bool
922WsfbCloseScreen(int scrnIndex, ScreenPtr pScreen)
923{
924	ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
925	WsfbPtr fPtr = WSFBPTR(pScrn);
926
927	TRACE_ENTER("WsfbCloseScreen");
928
929	if (pScrn->vtSema) {
930		WsfbRestore(pScrn);
931		if (munmap(fPtr->fbmem, fPtr->fbmem_len) == -1) {
932			xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
933				   "munmap: %s\n", strerror(errno));
934		}
935
936		fPtr->fbmem = NULL;
937	}
938#ifdef XFreeXDGA
939	if (fPtr->pDGAMode) {
940		xfree(fPtr->pDGAMode);
941		fPtr->pDGAMode = NULL;
942		fPtr->nDGAMode = 0;
943	}
944#endif
945	pScrn->vtSema = FALSE;
946
947	/* unwrap CloseScreen */
948	pScreen->CloseScreen = fPtr->CloseScreen;
949	return (*pScreen->CloseScreen)(scrnIndex, pScreen);
950}
951
952static void *
953WsfbWindowLinear(ScreenPtr pScreen, CARD32 row, CARD32 offset, int mode,
954		CARD32 *size, void *closure)
955{
956	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
957	WsfbPtr fPtr = WSFBPTR(pScrn);
958
959	if (fPtr->linebytes)
960		*size = fPtr->linebytes;
961	else {
962		if (ioctl(fPtr->fd, WSDISPLAYIO_LINEBYTES, size) == -1)
963			return NULL;
964		fPtr->linebytes = *size;
965	}
966	return ((CARD8 *)fPtr->fbmem + row *fPtr->linebytes + offset);
967}
968
969static void
970WsfbPointerMoved(int index, int x, int y)
971{
972    ScrnInfoPtr pScrn = xf86Screens[index];
973    WsfbPtr fPtr = WSFBPTR(pScrn);
974    int newX, newY;
975
976    switch (fPtr->rotate)
977    {
978    case WSFB_ROTATE_CW:
979	/* 90 degrees CW rotation. */
980	newX = pScrn->pScreen->height - y - 1;
981	newY = x;
982	break;
983
984    case WSFB_ROTATE_CCW:
985	/* 90 degrees CCW rotation. */
986	newX = y;
987	newY = pScrn->pScreen->width - x - 1;
988	break;
989
990    case WSFB_ROTATE_UD:
991	/* 180 degrees UD rotation. */
992	newX = pScrn->pScreen->width - x - 1;
993	newY = pScrn->pScreen->height - y - 1;
994	break;
995
996    default:
997	/* No rotation. */
998	newX = x;
999	newY = y;
1000	break;
1001    }
1002
1003    /* Pass adjusted pointer coordinates to wrapped PointerMoved function. */
1004    (*fPtr->PointerMoved)(index, newX, newY);
1005}
1006
1007static Bool
1008WsfbEnterVT(int scrnIndex, int flags)
1009{
1010	ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
1011
1012	TRACE_ENTER("EnterVT");
1013	pScrn->vtSema = TRUE;
1014	return TRUE;
1015}
1016
1017static void
1018WsfbLeaveVT(int scrnIndex, int flags)
1019{
1020#if DEBUG
1021	ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
1022#endif
1023
1024	TRACE_ENTER("LeaveVT");
1025}
1026
1027static Bool
1028WsfbSwitchMode(int scrnIndex, DisplayModePtr mode, int flags)
1029{
1030#if DEBUG
1031	ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
1032#endif
1033
1034	TRACE_ENTER("SwitchMode");
1035	/* Nothing else to do */
1036	return TRUE;
1037}
1038
1039static int
1040WsfbValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags)
1041{
1042#if DEBUG
1043	ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
1044#endif
1045
1046	TRACE_ENTER("ValidMode");
1047	return MODE_OK;
1048}
1049
1050static void
1051WsfbLoadPalette(ScrnInfoPtr pScrn, int numColors, int *indices,
1052	       LOCO *colors, VisualPtr pVisual)
1053{
1054	WsfbPtr fPtr = WSFBPTR(pScrn);
1055	struct wsdisplay_cmap cmap;
1056	unsigned char red[256],green[256],blue[256];
1057	int i, indexMin=256, indexMax=0;
1058
1059	TRACE_ENTER("LoadPalette");
1060
1061	cmap.count   = 1;
1062	cmap.red   = red;
1063	cmap.green = green;
1064	cmap.blue  = blue;
1065
1066	if (numColors == 1) {
1067		/* Optimisation */
1068		cmap.index = indices[0];
1069		red[0]   = colors[indices[0]].red;
1070		green[0] = colors[indices[0]].green;
1071		blue[0]  = colors[indices[0]].blue;
1072		if (ioctl(fPtr->fd,WSDISPLAYIO_PUTCMAP, &cmap) == -1)
1073			ErrorF("ioctl FBIOPUTCMAP: %s\n", strerror(errno));
1074	} else {
1075		/* Change all colors in 2 syscalls */
1076		/* and limit the data to be transfered */
1077		for (i = 0; i < numColors; i++) {
1078			if (indices[i] < indexMin)
1079				indexMin = indices[i];
1080			if (indices[i] > indexMax)
1081				indexMax = indices[i];
1082		}
1083		cmap.index = indexMin;
1084		cmap.count = indexMax - indexMin + 1;
1085		cmap.red = &red[indexMin];
1086		cmap.green = &green[indexMin];
1087		cmap.blue = &blue[indexMin];
1088		/* Get current map */
1089		if (ioctl(fPtr->fd, WSDISPLAYIO_GETCMAP, &cmap) == -1)
1090			ErrorF("ioctl FBIOGETCMAP: %s\n", strerror(errno));
1091		/* Change the colors that require updating */
1092		for (i = 0; i < numColors; i++) {
1093			red[indices[i]]   = colors[indices[i]].red;
1094			green[indices[i]] = colors[indices[i]].green;
1095			blue[indices[i]]  = colors[indices[i]].blue;
1096		}
1097		/* Write the colormap back */
1098		if (ioctl(fPtr->fd,WSDISPLAYIO_PUTCMAP, &cmap) == -1)
1099			ErrorF("ioctl FBIOPUTCMAP: %s\n", strerror(errno));
1100	}
1101	TRACE_EXIT("LoadPalette");
1102}
1103
1104static Bool
1105WsfbSaveScreen(ScreenPtr pScreen, int mode)
1106{
1107	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
1108	WsfbPtr fPtr = WSFBPTR(pScrn);
1109	int state;
1110
1111	TRACE_ENTER("SaveScreen");
1112
1113	if (!pScrn->vtSema)
1114		return TRUE;
1115
1116	if (mode != SCREEN_SAVER_FORCER) {
1117		state = xf86IsUnblank(mode)?WSDISPLAYIO_VIDEO_ON:
1118		                            WSDISPLAYIO_VIDEO_OFF;
1119		ioctl(fPtr->fd,
1120		      WSDISPLAYIO_SVIDEO, &state);
1121	}
1122	return TRUE;
1123}
1124
1125
1126static void
1127WsfbSave(ScrnInfoPtr pScrn)
1128{
1129	WsfbPtr fPtr = WSFBPTR(pScrn);
1130
1131	TRACE_ENTER("WsfbSave");
1132
1133	if (fPtr->info.cmsize == 0)
1134		return;
1135
1136	fPtr->saved_cmap.index = 0;
1137	fPtr->saved_cmap.count = fPtr->info.cmsize;
1138	if (ioctl(fPtr->fd, WSDISPLAYIO_GETCMAP,
1139		  &(fPtr->saved_cmap)) == -1) {
1140		xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
1141			   "error saving colormap %s\n", strerror(errno));
1142	}
1143
1144}
1145
1146static void
1147WsfbRestore(ScrnInfoPtr pScrn)
1148{
1149	WsfbPtr fPtr = WSFBPTR(pScrn);
1150	int mode;
1151
1152	TRACE_ENTER("WsfbRestore");
1153
1154	if (fPtr->info.cmsize != 0) {
1155		/* reset colormap for text mode */
1156		if (ioctl(fPtr->fd, WSDISPLAYIO_PUTCMAP,
1157			  &(fPtr->saved_cmap)) == -1) {
1158			xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
1159				   "error restoring colormap %s\n",
1160				   strerror(errno));
1161		}
1162	}
1163
1164	/* Clear the screen */
1165	memset(fPtr->fbmem, 0, fPtr->fbmem_len);
1166
1167	/* Restore the text mode */
1168	mode = WSDISPLAYIO_MODE_EMUL;
1169	if (ioctl(fPtr->fd, WSDISPLAYIO_SMODE, &mode) == -1) {
1170		xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
1171			   "error setting text mode %s\n", strerror(errno));
1172	}
1173	TRACE_EXIT("WsfbRestore");
1174}
1175
1176#ifdef XFreeXDGA
1177/***********************************************************************
1178 * DGA stuff
1179 ***********************************************************************/
1180
1181static Bool
1182WsfbDGAOpenFramebuffer(ScrnInfoPtr pScrn, char **DeviceName,
1183		       unsigned char **ApertureBase, int *ApertureSize,
1184		       int *ApertureOffset, int *flags)
1185{
1186	*DeviceName = NULL;		/* No special device */
1187	*ApertureBase = (unsigned char *)(pScrn->memPhysBase);
1188	*ApertureSize = pScrn->videoRam;
1189	*ApertureOffset = pScrn->fbOffset;
1190	*flags = 0;
1191
1192	return TRUE;
1193}
1194
1195static Bool
1196WsfbDGASetMode(ScrnInfoPtr pScrn, DGAModePtr pDGAMode)
1197{
1198	DisplayModePtr pMode;
1199	int scrnIdx = pScrn->pScreen->myNum;
1200	int frameX0, frameY0;
1201
1202	if (pDGAMode) {
1203		pMode = pDGAMode->mode;
1204		frameX0 = frameY0 = 0;
1205	} else {
1206		if (!(pMode = pScrn->currentMode))
1207			return TRUE;
1208
1209		frameX0 = pScrn->frameX0;
1210		frameY0 = pScrn->frameY0;
1211	}
1212
1213	if (!(*pScrn->SwitchMode)(scrnIdx, pMode, 0))
1214		return FALSE;
1215	(*pScrn->AdjustFrame)(scrnIdx, frameX0, frameY0, 0);
1216
1217	return TRUE;
1218}
1219
1220static void
1221WsfbDGASetViewport(ScrnInfoPtr pScrn, int x, int y, int flags)
1222{
1223	(*pScrn->AdjustFrame)(pScrn->pScreen->myNum, x, y, flags);
1224}
1225
1226static int
1227WsfbDGAGetViewport(ScrnInfoPtr pScrn)
1228{
1229	return (0);
1230}
1231
1232static DGAFunctionRec WsfbDGAFunctions =
1233{
1234	WsfbDGAOpenFramebuffer,
1235	NULL,       /* CloseFramebuffer */
1236	WsfbDGASetMode,
1237	WsfbDGASetViewport,
1238	WsfbDGAGetViewport,
1239	NULL,       /* Sync */
1240	NULL,       /* FillRect */
1241	NULL,       /* BlitRect */
1242	NULL,       /* BlitTransRect */
1243};
1244
1245static void
1246WsfbDGAAddModes(ScrnInfoPtr pScrn)
1247{
1248	WsfbPtr fPtr = WSFBPTR(pScrn);
1249	DisplayModePtr pMode = pScrn->modes;
1250	DGAModePtr pDGAMode;
1251
1252	do {
1253		pDGAMode = xrealloc(fPtr->pDGAMode,
1254				    (fPtr->nDGAMode + 1) * sizeof(DGAModeRec));
1255		if (!pDGAMode)
1256			break;
1257
1258		fPtr->pDGAMode = pDGAMode;
1259		pDGAMode += fPtr->nDGAMode;
1260		(void)memset(pDGAMode, 0, sizeof(DGAModeRec));
1261
1262		++fPtr->nDGAMode;
1263		pDGAMode->mode = pMode;
1264		pDGAMode->flags = DGA_CONCURRENT_ACCESS | DGA_PIXMAP_AVAILABLE;
1265		pDGAMode->byteOrder = pScrn->imageByteOrder;
1266		pDGAMode->depth = pScrn->depth;
1267		pDGAMode->bitsPerPixel = pScrn->bitsPerPixel;
1268		pDGAMode->red_mask = pScrn->mask.red;
1269		pDGAMode->green_mask = pScrn->mask.green;
1270		pDGAMode->blue_mask = pScrn->mask.blue;
1271		pDGAMode->visualClass = pScrn->bitsPerPixel > 8 ?
1272			TrueColor : PseudoColor;
1273		pDGAMode->xViewportStep = 1;
1274		pDGAMode->yViewportStep = 1;
1275		pDGAMode->viewportWidth = pMode->HDisplay;
1276		pDGAMode->viewportHeight = pMode->VDisplay;
1277
1278		if (fPtr->linebytes)
1279			pDGAMode->bytesPerScanline = fPtr->linebytes;
1280		else {
1281			ioctl(fPtr->fd, WSDISPLAYIO_LINEBYTES,
1282			      &fPtr->linebytes);
1283			pDGAMode->bytesPerScanline = fPtr->linebytes;
1284		}
1285
1286		pDGAMode->imageWidth = pMode->HDisplay;
1287		pDGAMode->imageHeight =  pMode->VDisplay;
1288		pDGAMode->pixmapWidth = pDGAMode->imageWidth;
1289		pDGAMode->pixmapHeight = pDGAMode->imageHeight;
1290		pDGAMode->maxViewportX = pScrn->virtualX -
1291			pDGAMode->viewportWidth;
1292		pDGAMode->maxViewportY = pScrn->virtualY -
1293			pDGAMode->viewportHeight;
1294
1295		pDGAMode->address = fPtr->fbstart;
1296
1297		pMode = pMode->next;
1298	} while (pMode != pScrn->modes);
1299}
1300
1301static Bool
1302WsfbDGAInit(ScrnInfoPtr pScrn, ScreenPtr pScreen)
1303{
1304	WsfbPtr fPtr = WSFBPTR(pScrn);
1305
1306	if (pScrn->depth < 8)
1307		return FALSE;
1308
1309	if (!fPtr->nDGAMode)
1310		WsfbDGAAddModes(pScrn);
1311
1312	return (DGAInit(pScreen, &WsfbDGAFunctions,
1313			fPtr->pDGAMode, fPtr->nDGAMode));
1314}
1315#endif
1316
1317static Bool
1318WsfbDriverFunc(ScrnInfoPtr pScrn, xorgDriverFuncOp op,
1319    pointer ptr)
1320{
1321	xorgHWFlags *flag;
1322
1323	switch (op) {
1324	case GET_REQUIRED_HW_INTERFACES:
1325		flag = (CARD32*)ptr;
1326		(*flag) = 0;
1327		return TRUE;
1328	default:
1329		return FALSE;
1330	}
1331}
1332
1333