 @@ -1,14 +1,14 @@
-/* $NetBSD: x68kFb.c,v 1.7 2020/11/04 17:16:13 tsutsui Exp $ */
+/* $NetBSD: x68kFb.c,v 1.8 2021/03/11 12:08: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.
+ *
 @@ -40,41 +40,41 @@ static int cons_dwidth;
  *            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" );
+        ErrorF( "Can't open frame buffer\n" );
         return FALSE;
+    }
     /* get frame buffer infomation */
     if ( ioctl( pPriv->fd, GRFIOCGINFO, &gi ) == -1 ) {
-        ErrorF( "Can't get grfinfo" );
+        ErrorF( "Can't get grfinfo\n" );
         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" );
+        ErrorF( "Can't map frame buffer\n" );
         return FALSE;
+    }
     pPriv->fb = (uint8_t *)((uint32_t)pPriv->reg + gi.gd_regsize);
     x68kRegSetup( pPriv );
     cons_dwidth = gi.gd_dwidth;
     return TRUE;
+}
 /*-------------------------------------------------------------------------
  * function "x68kFbCommonClose"
+ *
 @@ -104,27 +104,27 @@ x68kFbCommonClose(X68kScreenRec *pPriv)
 , 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(pPriv->reg, pPriv->mapsize) == -1 )
-        ErrorF("Can't unmap frame buffer");
+        ErrorF("Can't unmap frame buffer\n");
     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

 @@ -1,14 +1,14 @@
-/* $NetBSD: x68kGraph.c,v 1.9 2020/11/04 17:16:13 tsutsui Exp $ */
+/* $NetBSD: x68kGraph.c,v 1.10 2021/03/11 12:08: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.
+ *
 @@ -185,27 +185,27 @@ x68kGraphClose(X68kScreenRec *pPriv)
  *  returns:  (Bool) : TRUE  if succeeded
  *                     FALSE otherwise
  *-----------------------------------------------------------------------*/
 Bool
 x68kGraphInit(ScreenPtr pScreen, int argc, char *argv[])
+{
     X68kScreenRec *pPriv;
     /* get private screen record set by X68KConfig */
     pPriv = x68kGetScreenRecByType(X68K_FB_GRAPHIC);
     /* store private record into screen */
     if (!dixRegisterPrivateKey(&x68kScreenPrivateKeyRec, PRIVATE_SCREEN, 0)) {
-        ErrorF("dixRegisterPrivateKey failed");
+        ErrorF("dixRegisterPrivateKey failed\n");
         return FALSE;
+    }
     x68kSetScreenPrivate(pScreen, pPriv);
     /* register normal cfb screen functions */
     if (!fbSetupScreen(pScreen, pPriv->fb,
                        pPriv->scr_width, pPriv->scr_height,
                        pPriv->dpi, pPriv->dpi, pPriv->fb_width,
 		       pPriv->depth))
 	return FALSE;
     /* register colormap functions */
     pScreen->InstallColormap = x68kInstallColormap;

 @@ -1,14 +1,14 @@
-/* $NetBSD: x68kMouse.c,v 1.9 2021/02/07 16:55:18 tsutsui Exp $ */
+/* $NetBSD: x68kMouse.c,v 1.10 2021/03/11 12:08: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.
+ *
 @@ -126,27 +126,27 @@ x68kMouseProc(DeviceIntPtr device, int w
     int		format;
     static int	oformat;
     BYTE	map[4];
     Atom btn_labels[3] = {0};
     Atom axes_labels[2] = { 0, 0 };
     MouseEmu3btnPtr pEmu3btn;
     Bool emu3enable;
     int emu3timeout;
     switch (what) {
 	case DEVICE_INIT:
             pMouse->devicePrivate = (void *) &x68kMousePriv;
             if( (x68kMousePriv.fd = open("/dev/mouse", O_RDONLY)) == -1 ) {
-                ErrorF("Can't open mouse device");
+                ErrorF("Can't open mouse device\n");
                 return !Success;
+            }
 	    pMouse->on = FALSE;
 	    map[1] = 1;
 	    map[2] = 2;
 	    map[3] = 3;
 	    btn_labels[0] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_LEFT);
 	    btn_labels[1] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_MIDDLE);
 	    btn_labels[2] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_RIGHT);
 	    axes_labels[0] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_X);
 	    axes_labels[1] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_Y);
 	    InitPointerDeviceStruct(pMouse, map, 3, btn_labels,
 @@ -155,54 +155,54 @@ x68kMouseProc(DeviceIntPtr device, int w
 	    /* Initialize emulation 3 buttons settings */
 	    emu3enable = TRUE;			/* XXX should be configurable */
 	    emu3timeout = EMU3B_DEF_TIMEOUT;	/* XXX should be configurable */
 	    if (emu3enable) {
 		pEmu3btn = &x68kMousePriv.emu3btn;
 		Emulate3ButtonsEnable(pEmu3btn, device, emu3timeout);
+	    }
 	    break;
 	case DEVICE_ON:
 	    if (ioctl (x68kMousePriv.fd, VUIDGFORMAT, &oformat) == -1) {
-		ErrorF("x68kMouseProc ioctl VUIDGFORMAT");
+		ErrorF("x68kMouseProc ioctl VUIDGFORMAT\n");
 		return !Success;
+	    }
 	    format = VUID_FIRM_EVENT;
 	    if (ioctl (x68kMousePriv.fd, VUIDSFORMAT, &format) == -1) {
-		ErrorF("x68kMouseProc ioctl VUIDSFORMAT");
+		ErrorF("x68kMouseProc ioctl VUIDSFORMAT\n");
 		return !Success;
+	    }
             if ( fcntl(x68kMousePriv.fd, F_SETOWN, getpid()) == -1 ||
                  fcntl(x68kMousePriv.fd, F_SETFL, O_NONBLOCK | O_ASYNC) == -1
                  ) {
-                ErrorF("Async mouse I/O failed");
+                ErrorF("Async mouse I/O failed\n");
                 return !Success;
+            }
 	    x68kMousePriv.bmask = 0;
 	    SetNotifyFd(x68kMousePriv.fd, x68kMouseHandlerNotify,
 		X_NOTIFY_READ, NULL);
 	    pMouse->on = TRUE;
 	    break;
 	case DEVICE_OFF:
 	    pMouse->on = FALSE;
 	    RemoveNotifyFd(x68kMousePriv.fd);
 	    break;
 	case DEVICE_CLOSE:
 	    if (ioctl (x68kMousePriv.fd, VUIDSFORMAT, &oformat) == -1)
-		ErrorF("x68kMouseProc ioctl VUIDSFORMAT");
+		ErrorF("x68kMouseProc ioctl VUIDSFORMAT\n");
 	    break;
+    }
     return Success;
+}
 /*-
  *-----------------------------------------------------------------------
  * x68kMouseCtrl --
  *	Alter the control parameters for the mouse. Since acceleration
  *	etc. is done from the PtrCtrl record in the mouse's device record,
  *	there's nothing to do here.
+ *
 @@ -236,27 +236,27 @@ x68kMouseCtrl(DeviceIntPtr device, PtrCt
  */
 Firm_event *
 x68kMouseGetEvents(int fd, int *pNumEvents, Bool *pAgain)
+{
     int nBytes;               /* number of bytes of events available. */
     static Firm_event evBuf[X68K_MAXEVENTS];     /* Buffer for Firm_events */
     if ((nBytes = read (fd, (char *)evBuf, sizeof(evBuf))) == -1) {
 	if (errno == EWOULDBLOCK) {
 	    *pNumEvents = 0;
 	    *pAgain = FALSE;
 	} else {
-	    ErrorF("x68kMouseGetEvents read");
+	    ErrorF("x68kMouseGetEvents read\n");
 	    FatalError ("Could not read from mouse");
+	}
     } else {
 	*pNumEvents = nBytes / sizeof (Firm_event);
 	*pAgain = (nBytes == sizeof (evBuf));
+    }
     return evBuf;
+}
 /*-
  *-----------------------------------------------------------------------
  * x68kMouseEnqueueEvent --
  *	Given a Firm_event for a mouse, pass it off the the dix layer

 @@ -1,14 +1,14 @@
-/* $NetBSD: x68kKbd.c,v 1.10 2020/11/04 17:16:13 tsutsui Exp $ */
+/* $NetBSD: x68kKbd.c,v 1.11 2021/03/11 12:08: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.
+ *
 @@ -111,52 +111,52 @@ x68kKbdHandlerNotify(int fd __unused, in
 int
 x68kKbdProc(DeviceIntPtr pDev,	/* Keyboard to manipulate */
             int what)		/* What to do to it */
+{
     DevicePtr pKeyboard = &pDev->public;
     CARD8 x68kModMap[MAP_LENGTH];
     int mode;
     XkbRMLVOSet rmlvo;
     switch (what) {
         case DEVICE_INIT:
             pKeyboard->devicePrivate = (void *)&x68kKbdPriv;
             if( (x68kKbdPriv.fd = open("/dev/kbd", O_RDONLY)) == -1 ) {
-                ErrorF("Can't open keyboard device");
+                ErrorF("Can't open keyboard device\n");
                 return !Success;
+            }
             pKeyboard->on = FALSE;
             x68kInitModMap(x68kKeySyms, x68kModMap);
             x68kInitKbdNames(&rmlvo, pKeyboard->devicePrivate);
 #if 0 /* XXX How should we setup XKB maps for non PS/2 keyboard!? */
             InitKeyboardDeviceStruct(pDev, &rmlvo,
                                      x68kKbdBell, x68kKbdCtrl);
 #else
             InitKeyboardDeviceStruct(pDev, NULL,
                                      x68kKbdBell, x68kKbdCtrl);
 	    XkbApplyMappingChange(pDev, x68kKeySyms,
 		x68kKeySyms->minKeyCode,
 		x68kKeySyms->maxKeyCode - x68kKeySyms->minKeyCode + 1,
 		x68kModMap, serverClient);
 #endif
             break;
         case DEVICE_ON:
             mode = 1;
             if ( fcntl(x68kKbdPriv.fd, F_SETOWN, getpid()) == -1 ||
                  fcntl(x68kKbdPriv.fd, F_SETFL, O_NONBLOCK|O_ASYNC) == -1 ||
                  ioctl(x68kKbdPriv.fd, KIOCSDIRECT, &mode) == -1 ) {
-                ErrorF("Async keyboard I/O failed");
+                ErrorF("Async keyboard I/O failed\n");
                 return !Success;
+            }
 	    x68kSetLeds(&x68kKbdPriv, (uint8_t)x68kKbdPriv.leds);
             SetNotifyFd(x68kKbdPriv.fd, x68kKbdHandlerNotify,
 		X_NOTIFY_READ, NULL);
             pKeyboard->on = TRUE;
             break;
         case DEVICE_CLOSE:
         case DEVICE_OFF:
             RemoveNotifyFd(x68kKbdPriv.fd);
             pKeyboard->on = FALSE;
             break;
 @@ -261,27 +261,27 @@ x68kInitKbdNames(XkbRMLVOSet *rmlvo, X68
  *-----------------------------------------------------------------------
  */
 Firm_event *
 x68kKbdGetEvents(int fd, int *pNumEvents, Bool *pAgain)
+{
     int nBytes;		/* number of bytes of events available. */
     static Firm_event evBuf[X68K_MAXEVENTS];	/* Buffer for Firm_events */
     if ((nBytes = read (fd, evBuf, sizeof(evBuf))) == -1) {
 	if (errno == EWOULDBLOCK) {
 	    *pNumEvents = 0;
 	    *pAgain = FALSE;
 	} else {
-	    ErrorF("Reading keyboard");
+	    ErrorF("Reading keyboard\n");
 	    FatalError ("Could not read the keyboard");
+	}
     } else {
 	*pNumEvents = nBytes / sizeof (Firm_event);
 	*pAgain = (nBytes == sizeof (evBuf));
+    }
     return evBuf;
+}
 /*-
  *-----------------------------------------------------------------------
  * x68kKbdEnqueueEvent --
+ *
 @@ -314,33 +314,33 @@ x68kKbdEnqueueEvent(DeviceIntPtr pDev, F
  */
 static void
 x68kKbdRingBell(DeviceIntPtr pDev, int volume, int duration)
+{
     int		    kbdCmd;	/* Command to give keyboard */
     X68kKbdPrivPtr  pPriv = (X68kKbdPrivPtr)pDev->public.devicePrivate;
     if (volume == 0)
 	return;
     kbdCmd = KBD_CMD_BELL;
     if (ioctl (pPriv->fd, KIOCCMD, &kbdCmd) == -1) {
-	ErrorF("Failed to activate bell");
+	ErrorF("Failed to activate bell\n");
 	return;
+    }
     usleep (duration * 1000);
     kbdCmd = KBD_CMD_NOBELL;
     if (ioctl (pPriv->fd, KIOCCMD, &kbdCmd) == -1)
-	ErrorF("Failed to deactivate bell");
+	ErrorF("Failed to deactivate bell\n");
+}
 static void
 x68kKbdBell(int volume, DeviceIntPtr pDev, void *ctrl, int unused)
+{
     KeybdCtrl*      kctrl = (KeybdCtrl*) ctrl;
     if (kctrl->bell == 0)
 	return;
     x68kKbdRingBell(pDev, volume, kctrl->bell_duration);
+}
 @@ -389,23 +389,23 @@ x68kKbdCtrl(DeviceIntPtr pDev, KeybdCtrl
 /*-------------------------------------------------------------------------
  * function "x68kSetLeds"
+ *
  *  purpose:  set keyboard leds to specified state
  *  argument: (X68kKbdPrivPtr)pPriv
  *            (uint8_t)data;
  *  returns:  nothing
  *-----------------------------------------------------------------------*/
 static void
 x68kSetLeds(X68kKbdPrivPtr pPriv, uint8_t data)
+{
     /* bit sequence of led indicator in xkb and hardware are same */
     if (ioctl(pPriv->fd, KIOCSLED, &data) == -1)
-        ErrorF("Failed to set keyboard lights");
+        ErrorF("Failed to set keyboard lights\n");
+}
 Bool
 LegalModifier(unsigned int key, DeviceIntPtr pDev)
+{
     return TRUE;
+}
 /* EOF x68kKbd.c */

 @@ -1,14 +1,14 @@
-/* $NetBSD: x68kText.c,v 1.5 2020/11/04 17:16:13 tsutsui Exp $ */
+/* $NetBSD: x68kText.c,v 1.6 2021/03/11 12:08: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.
+ *
 @@ -89,27 +89,27 @@ x68kTextClose(X68kScreenRec *pPriv)
  *            (int)argc, (char **)argv : standard C arguments
  *  returns:  (Bool) TRUE  if succeeded
  *                   FALSE otherwise
  *-----------------------------------------------------------------------*/
 Bool
 x68kTextInit(ScreenPtr pScreen, int argc, char *argv[])
+{
     X68kScreenRec *pPriv;
     /* get private screen record set by X68KConfig */
     pPriv = x68kGetScreenRecByType(X68K_FB_TEXT);
     if ( !dixRegisterPrivateKey(&x68kScreenPrivateKeyRec, PRIVATE_SCREEN, 0) ) {
-            ErrorF("dixRegisterPrivateKey failed");
+            ErrorF("dixRegisterPrivateKey failed\n");
             return FALSE;
+    }
     x68kSetScreenPrivate(pScreen, pPriv);
     if ( !fbScreenInit(pScreen, pPriv->fb,
                         pPriv->scr_width, pPriv->scr_height,
                         pPriv->dpi, pPriv->dpi, pPriv->fb_width, 1) )
         return FALSE;
     pScreen->whitePixel = 1;
     pScreen->blackPixel = 0;
     if ( !miDCInitialize(pScreen, &x68kPointerScreenFuncs) )
         return FALSE;
     if ( !miCreateDefColormap(pScreen) )