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