 @@ -1,173 +1,173 @@
-/* $NetBSD: x68k.h,v 1.5 2020/07/22 21:24:20 tsutsui Exp $ */
+/* $NetBSD: x68k.h,v 1.6 2020/11/03 15:52:57 tsutsui Exp $ */
 /*-------------------------------------------------------------------------
  * Copyright (c) 1996 Yasushi Yamasaki
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *-----------------------------------------------------------------------*/
 /* system */
 #include <stdlib.h>
 #include <stdio.h>
 #include <errno.h>
 #include <signal.h>
 #include <sys/types.h>
 #include <sys/time.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 #include <fcntl.h>
 #include <unistd.h>
 /* machine dependent */
 #include <machine/vuid_event.h>
 #include <machine/kbd.h>
 #include <machine/kbio.h>
 #include <machine/grfioctl.h>
 /* generic X */
 #include <X11/X.h>
 #include <X11/Xmd.h>
 #define XK_KATAKANA
 #include <X11/keysym.h>
 #define NEED_EVENTS
 #include <X11/Xproto.h>
 /* dix */
 #include <misc.h>
 #include <scrnintstr.h>
 #include <screenint.h>
 #include <input.h>
 #include <inputstr.h>
 #include <servermd.h>
 #include <colormap.h>
 #include <colormapst.h>
 /* mi */
 #include <mipointer.h>
 #include "x68kReg.h"
 /*
  * X68k dependent screen record
  */
 typedef struct _X68kScreenRec {
     int type;                   /* frame buffer type   */
     int class;                  /* visual class        */
     int fd;                     /* file descriptor     */
     int depth;                  /* depth               */
     int fb_width;               /* frame buffer width  */
     int fb_height;              /* frame buffer height */
     int scr_width;              /* screen width        */
     int scr_height;             /* screen height       */
     int dpi;                    /* dots per inch       */
     uint8_t *fb;                /* frame buffer VA     */
-    volatile FbReg *reg;        /* control register VA */
+    FbReg *reg;                 /* control register VA */
     X68kFbReg x68kreg;          /* control register    */
     int mapsize;                /* size of mapped memory */
     ColormapPtr installedMap;   /* installed colormap    */
 } X68kScreenRec;
 /*
  * frame buffer procedures
  */
 typedef struct _X68kFbProcRec {
     Bool (*open)(X68kScreenRec *);		 /* open procedure       */
     Bool (*init)(ScreenPtr, int, char *[]);      /* initialize procedure */
     void (*close)(X68kScreenRec *);		 /* close procedure      */
 } X68kFbProcRec;
 /* frame buffer types */
 #define X68K_FB_NULL    0
 #define X68K_FB_TEXT    1       /* text VRAM frame buffer */
 #define X68K_FB_GRAPHIC 2       /* graphic VRAM frame buffer */
 #if 0
 #define X68K_FB_CIRRUS  3       /* not yet */
 #endif
 #define X68K_FB_TYPES   2
 typedef struct _X68kMousePriv {
     int fd;
     int bmask;
 } X68kMousePriv, *X68kMousePrivPtr;
 typedef struct _X68kKbdPriv {
     int type;
     int fd;
     Leds leds;
 } X68kKbdPriv, *X68kKbdPrivPtr;
 /* keyboard types */
 #define X68K_KB_STANDARD 0      /* standard keyboard */
 #define X68K_KB_ASCII    1      /* ascii map keyboard */
 #define X68K_MAXEVENTS 32
 extern DevPrivateKeyRec x68kScreenPrivateKeyRec;
 #define x68kScreenPrivateKey (&x68kScreenPrivateKeyRec)
 #define x68kSetScreenPrivate(pScreen, v) \
     dixSetPrivate(&(pScreen)->devPrivates, x68kScreenPrivateKey, (v))
 #define x68kGetScreenPrivate(pScreen) ((X68kScreenRec *) \
     dixLookupPrivate(&(pScreen)->devPrivates, x68kScreenPrivateKey))
 /* in x68kConfig.c */
 X68kScreenRec *x68kGetScreenRec(int);
 X68kScreenRec *x68kGetScreenRecByType(int);
 X68kFbProcRec *x68kGetFbProcRec(int index);
 void x68kRegisterPixmapFormats(ScreenInfo *);
 int x68kConfig(void);
 extern const char *configFilename;
 /* x68kFB.c */
 Bool x68kFbCommonOpen(X68kScreenRec *, const char *);
 void x68kFbCommonClose(X68kScreenRec *);
 Bool x68kSaveScreen(ScreenPtr, int);
 /* x68kGraph.c */
 Bool x68kGraphOpen(X68kScreenRec *);
 Bool x68kGraphInit(ScreenPtr, int, char *[]);
 void x68kGraphClose(X68kScreenRec *);
 /* in x68kIo.c */
 void x68kSigIOHandler(int);
 /* in x68kMouse.c */
 int x68kMouseProc(DeviceIntPtr, int);
 Firm_event *x68kMouseGetEvents(int, int *, Bool *);
 void x68kMouseEnqueueEvent(DeviceIntPtr, Firm_event *);
 extern miPointerScreenFuncRec x68kPointerScreenFuncs;
 extern DeviceIntPtr x68kPointerDevice;
 /* in x68kKbd.c */
 int x68kKbdProc(DeviceIntPtr, int);
 Firm_event *x68kKbdGetEvents(int, int *, Bool *);
 void x68kKbdEnqueueEvent(DeviceIntPtr, Firm_event *);
 extern X68kKbdPriv x68kKbdPriv;
 extern DeviceIntPtr x68kKeyboardDevice;
 /* in x68kKeyMap.c */
 extern KeySymsRec jisKeySyms, asciiKeySyms, *x68kKeySyms;
 /* x68kText.c */
 Bool x68kTextOpen(X68kScreenRec *);
 Bool x68kTextInit(ScreenPtr, int, char *[]);
 void x68kTextClose(X68kScreenRec *);
 /* EOF x68k.h */

 @@ -1,195 +1,195 @@
-/* $NetBSD: x68kFb.c,v 1.5 2020/11/03 15:25:21 tsutsui Exp $ */
+/* $NetBSD: x68kFb.c,v 1.6 2020/11/03 15:52:57 tsutsui Exp $ */
 /*-------------------------------------------------------------------------
  * Copyright (c) 1996 Yasushi Yamasaki
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *-----------------------------------------------------------------------*/
 #include "x68k.h"
 static void x68kRegSetup(X68kScreenRec *pPriv);
 DevPrivateKeyRec x68kScreenPrivateKeyRec;
 static int cons_dwidth;
 /*-------------------------------------------------------------------------
  * function "x68kFbCommonOpen"
+ *
  *  purpose:  open and map frame buffer, and obtain some FB-specific
  *            infomation. then set controller to approppriate mode as
  *            configured in X68kConfig.
  *  argument: (X68kScreenRec *)pPriv : X68k private screen record
  *            (const char *)device   : name of frame buffer device
  *  returns:  (Bool): TRUE  if succeeded
  *                    FALSE otherwise
  *-----------------------------------------------------------------------*/
 Bool
 x68kFbCommonOpen(X68kScreenRec *pPriv, const char *device)
+{
     struct grfinfo gi;
     /* open frame buffer */
     if ( ( pPriv->fd = open(device, O_RDWR, 0)) < 0) {
         ErrorF( "Can't open frame buffer" );
         return FALSE;
+    }
     /* get frame buffer infomation */
     if ( ioctl( pPriv->fd, GRFIOCGINFO, &gi ) == -1 ) {
         ErrorF( "Can't get grfinfo" );
         return FALSE;
+    }
     pPriv->mapsize = gi.gd_regsize + gi.gd_fbsize;
     /* map control registers and frame buffer */
     pPriv->reg = (FbReg *)mmap(0, pPriv->mapsize, PROT_READ | PROT_WRITE,
                                MAP_FILE | MAP_SHARED, pPriv->fd, 0 );
     if ( pPriv->reg == (FbReg *)-1) {
         ErrorF( "Can't map frame buffer" );
         return FALSE;
+    }
     pPriv->fb = (uint8_t *)((uint32_t)pPriv->reg + gi.gd_regsize);
     x68kRegSetup( pPriv );
     cons_dwidth = gi.gd_dwidth;
     return TRUE;
+}
 /*-------------------------------------------------------------------------
  * function "x68kFbCommonClose"
+ *
  *  purpose:  unmap and close frame buffer, and
  *            change video mode to normal ITE mode
  *  argument: (X68kScreenRec *)pPriv : X68k private screen record
  *  returns:  nothing
  *-----------------------------------------------------------------------*/
 void
 x68kFbCommonClose(X68kScreenRec *pPriv)
+{
     static const X68kFbReg graphNone_mode16 = {
 	/* CRT mode 16 (768x512 31.5kHz) */
         { 137,14, 28, 124,
 , 5, 40, 552,
 , 0,  0,   0,
 , 0,  0,   0,
 , 0,  0,   0,
 x0416, 0,  0,   0, 0 },
         { 0x0004, 0x21e4, 0x0020 },
     };
     static const X68kFbReg graphNone_mode19 = {
 	/* CRT mode 19 (640x480 31.5kHz VGA mode) */
         {  99,11, 13,  93,
 , 1, 33, 513,
 , 0,  0,   0,
 , 0,  0,   0,
 , 0,  0,   0,
 x0417, 0,  0,   0, 0 },
         { 0x0004, 0x21e4, 0x0020 },
     };
     /* change video mode */
     pPriv->x68kreg = (cons_dwidth == 640) ? graphNone_mode19 : graphNone_mode16;
     x68kRegSetup(pPriv);
     /* unmap and close frame buffer */
-    if ( munmap(__UNVOLATILE(pPriv->reg), pPriv->mapsize) == -1 )
+    if ( munmap(pPriv->reg, pPriv->mapsize) == -1 )
         ErrorF("Can't unmap frame buffer");
     close(pPriv->fd);
+}
 /*-------------------------------------------------------------------------
  * function "x68kRegSetup"
+ *
  *  purpose:  set up CRT controller and Video controller
  *            with register values in pPriv->x68kreg
  *  argument: (X68kScreenRec *)pPriv : X68k private screen record
  *  returns:  nothing
  *-----------------------------------------------------------------------*/
 #define CRTCSET(r) pPriv->reg->crtc.r = pPriv->x68kreg.crtc.r
 #define VIDEOCSET(r) pPriv->reg->videoc.r = pPriv->x68kreg.videoc.r
 static void
 x68kRegSetup(X68kScreenRec *pPriv)
+{
     u_short pr20 = pPriv->reg->crtc.r20;
     /* timing registers */
     if ( (pr20 & 0x0003) < (pPriv->x68kreg.crtc.r20 & 0x0003) ||
          ( (pr20 & 0x0003) == (pPriv->x68kreg.crtc.r20 & 0x0003) &&
            (pr20 & 0x0010) < (pPriv->x68kreg.crtc.r20 & 0x0010) ) ) {
         /* to higher resolution */
         CRTCSET(r00); CRTCSET(r01); CRTCSET(r02);CRTCSET(r03);
         CRTCSET(r04); CRTCSET(r05); CRTCSET(r06);CRTCSET(r07);
         CRTCSET(r20);
     } else {
         /* to lower resolution */
         CRTCSET(r20); CRTCSET(r01); CRTCSET(r02);CRTCSET(r03);
         CRTCSET(r04); CRTCSET(r05); CRTCSET(r06);CRTCSET(r07);
         CRTCSET(r00);
+    }
     CRTCSET(r08);
     /* scroll registers */
     CRTCSET(r12); CRTCSET(r13); CRTCSET(r14);CRTCSET(r15);
     CRTCSET(r16); CRTCSET(r17); CRTCSET(r18);CRTCSET(r19);
     /* mode controlling registers */
     VIDEOCSET(r0); VIDEOCSET(r1); VIDEOCSET(r2);
     /* dot clock bit */
     pPriv->reg->sysport.r4 = (pPriv->x68kreg.dotClock)? 0x000e: 0x000c;
+}
 /*-------------------------------------------------------------------------
  * function "x68kSaveScreen"                      [ screen function ]
+ *
  *  purpose:  activate/deactivate screen saver
  *  argument: (ScreenPtr)ipScreen : target screen to save
  *            (int)mode          : on/off
  *  returns:  nothing
  *-----------------------------------------------------------------------*/
 Bool
 x68kSaveScreen(ScreenPtr pScreen, Bool on)
+{
     X68kScreenRec *pPriv = x68kGetScreenPrivate(pScreen);
     static int status = FALSE;
     static u_short r2;
     if (on == SCREEN_SAVER_ON || on == SCREEN_SAVER_CYCLE) {
         if (!status) {
             r2 = pPriv->reg->videoc.r2;
             pPriv->reg->videoc.r2 = 0x0000;
             status = TRUE;
+        }
     } else {
         if (status) {
             pPriv->reg->videoc.r2 = r2;
             status = FALSE;
+        }
+    }
     return TRUE;
+}
 /* EOF x68kFb.c */

 @@ -1,90 +1,90 @@
-/* $NetBSD: x68kReg.h,v 1.3 2020/08/01 20:09:03 tsutsui Exp $ */
+/* $NetBSD: x68kReg.h,v 1.4 2020/11/03 15:52:57 tsutsui Exp $ */
 /*-------------------------------------------------------------------------
  * Copyright (c) 1996 Yasushi Yamasaki
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *-----------------------------------------------------------------------*/
 /*
  * CRT controller
  */
 typedef struct {
-    u_short r00, r01, r02, r03, r04, r05, r06, r07;
+    volatile u_short r00, r01, r02, r03, r04, r05, r06, r07;
-    u_short r08, r09, r10, r11, r12, r13, r14, r15;
+    volatile u_short r08, r09, r10, r11, r12, r13, r14, r15;
-    u_short r16, r17, r18, r19, r20, r21, r22, r23;
+    volatile u_short r16, r17, r18, r19, r20, r21, r22, r23;
     char pad0[0x450];
-    u_short ctrl;
+    volatile u_short ctrl;
     char pad1[0x1b7e];
 } Crtc;
 typedef struct {
     u_short r00, r01, r02, r03, r04, r05, r06, r07;
     u_short r08, r09, r10, r11, r12, r13, r14, r15;
     u_short r16, r17, r18, r19, r20, r21, r22, r23;
     u_short ctrl;
 } X68kCrtc;
 /*
  * video controller
  */
 typedef struct {
-    u_short r0;
+    volatile u_short r0;
     char pad0[0xfe];
-    u_short r1;
+    volatile u_short r1;
     char pad1[0xfe];
-    u_short r2;
+    volatile u_short r2;
     char pad2[0x19fe];
 } Videoc;
 typedef struct {
     u_short r0;
     u_short r1;
     u_short r2;
 } X68kVideoc;
 /* system port */
 typedef struct {
-    u_short r1, r2, r3, r4;
+    volatile u_short r1, r2, r3, r4;
     u_short pad0[2];
-    u_short r5, r6;
+    volatile u_short r5, r6;
     u_short pad[0x1ff0];
 } Sysport;
 /*
  * control registers
  */
 typedef struct {
     Crtc crtc;
-    u_short gpal[256];    /* graphic palette */
+    volatile u_short gpal[256];    /* graphic palette */
-    u_short tpal[256];     /* text palette */
+    volatile u_short tpal[256];     /* text palette */
     Videoc videoc;
     u_short pad0[0xa000];
     Sysport sysport;
 } FbReg;
 typedef struct {
     X68kCrtc crtc;
     X68kVideoc videoc;
     char dotClock;
 } X68kFbReg;
 /* EOF x68kReg.h */