diff --git a/server/drivers/glk.c b/server/drivers/glk.c
index e0330ec..edf2b6e 100644
--- a/server/drivers/glk.c
+++ b/server/drivers/glk.c
@@ -27,15 +27,20 @@
 # endif
 #endif
 
+#define DEBUG 1
 #include "lcd.h"
 #include "shared/str.h"
 #include "glk.h"
 #include "glkproto.h"
 #include "report.h"
 
+#include "adv_bignum.h"
+
 #define GLK_DEFAULT_DEVICE	"/dev/lcd"
 #define GLK_DEFAULT_SPEED	19200
 #define GLK_DEFAULT_CONTRAST	560
+#define GLK_DEFAULT_CELLWIDTH	6
+#define GLK_DEFAULT_CELLHEIGHT	8
 
 
 //////////////////////////////////////////////////////////////////////////
@@ -44,18 +49,23 @@
 
 typedef struct driver_private_data {
   char device[256];
-  GLKDisplay *PortFD;
+  GLKDisplay *fd;
   speed_t speed;
 
-  unsigned char *screen_contents;
+  const char *model;
+
   int fontselected;
   int gpo_count;
 
   unsigned char *framebuf;
+  unsigned char *backingstore;
+
   int width;
   int height;
+
   int cellwidth;
   int cellheight;
+
   int contrast;
 
   int clearcount;
@@ -88,14 +98,14 @@ glk_init(Driver *drvthis)
     return -1;
 
   /* initialize private data */
-  p->PortFD = NULL;
+  p->fd = NULL;
   p->speed = GLK_DEFAULT_SPEED;
-  p->screen_contents = NULL;
+  p->backingstore = NULL;
   p->fontselected = -1;		// No font selected
   p->gpo_count = 0;
   p->framebuf = NULL;
-  p->cellwidth = LCD_DEFAULT_CELLWIDTH;
-  p->cellheight = LCD_DEFAULT_CELLHEIGHT;
+  p->cellwidth = GLK_DEFAULT_CELLWIDTH;
+  p->cellheight = GLK_DEFAULT_CELLHEIGHT;
   p->contrast = GLK_DEFAULT_SPEED;
   p->clearcount = 0;
 
@@ -112,14 +122,17 @@ glk_init(Driver *drvthis)
 
   if (p->speed == 9600)       p->speed = B9600;
   else if (p->speed == 19200) p->speed = B19200;
-  else if (p->speed == 38400) p->speed = B38400;
+  // not in the specs:
+  //else if (p->speed == 38400) p->speed = B38400;
+  else if (p->speed == 57600) p->speed = B57600;
+  else if (p->speed == 115200) p->speed = B115200;
   else {
-    report(RPT_WARNING, "%s: illegal Speed: %d; must be one of 9600, 19200 or 38400; using default %d",
-		    drvthis->name, p->speed, 19200);
+    report(RPT_WARNING, "%s: illegal Speed: %d; must be one of 9600, 19200, 57600 or 115200; using default %d",
+		    drvthis->name, p->speed, GLK_DEFAULT_SPEED);
     p->speed = B19200;
   }
 
-  /* Which p->contrast */
+  /* Which contrast */
   p->contrast = drvthis->config_get_int(drvthis->name, "Contrast" , 0 , GLK_DEFAULT_CONTRAST);
   if ((p->contrast < 0) || (p->contrast > 1000)) {
     report(RPT_WARNING, "%s: Contrast must be between 0 and 1000. Using default %d",
@@ -130,61 +143,74 @@ glk_init(Driver *drvthis)
   /* End of config file parsing */
 
   /* open device */
-  p->PortFD = glkopen(p->device, p->speed);
-  if (p->PortFD == NULL) {
+  p->fd = glkopen(p->device, p->speed);
+  if (p->fd == NULL) {
     report(RPT_ERR, "%s: unable to open device %s", drvthis->name, p->device);
     return -1;
   }
 
   // Query the module for a device type
-  glkputl(p->PortFD, GLKCommand, 0x37, EOF);
-  i = glkget(p->PortFD);
+  glkputl(p->fd, GLKCommand, 0x37, EOF);
+  i = glkget(p->fd);
   if (i < 0) {
     report(RPT_ERR, "%s: GLK did not respond to READ MODULE TYPE", drvthis->name);
     return -1;
   }
   else {
     switch (i) {
-      case 0x10 :  // GLC12232
+      case 0x10 :
+        p->model = "GLC12232";
 	p->width = 20; p->height = 4;
 	break;
-      case 0x11 :  // GLC12864
+      case 0x11 :
+        p->model = "GLC12864";
 	p->width = 20; p->height = 8;
 	break;
-      case 0x12 :  // GLC128128
+      case 0x12 :
+        p->model = "GLC128128";
 	p->width = 20; p->height = 16;
 	break;
-      case 0x13 :  // GLC24064
-	p->width = 40; p->height = 8; p->gpo_count = 1;
+      case 0x13 :
+        p->model = "GLC24064";
+	p->width = 40; p->height = 8;
+	p->gpo_count = 1;
 	break;
-      case 0x14 :  // GLK12864-25
+      case 0x14 :
+        p->model = "GLK12864-25";
 	p->width = 20; p->height = 8;
 	break;
-      case 0x15 :  // GLK24064-25
-	p->width = 40; p->height = 8; p->gpo_count = 1;
+      case 0x15 :
+        p->model = "GLK24064-25";
+	p->width = 40; p->height = 8;
+	p->gpo_count = 1;
 	break;
-      case 0x21 :  // GLK128128-25
+      case 0x21 :
+        p->model = "GLK128128-25";
 	p->width = 20; p->height = 16;
 	break;
-      case 0x22 :  // GLK12232-25
-	p->width = 20; p->height = 4; p->gpo_count = 2;
+      case 0x22 :
+        p->model = "GLK12232-25";
+	p->width = 20; p->height = 4;
+	p->gpo_count = 2;
 	break;
-      case 0x23 :  // GLK12232-25SM
-	p->width = 20; p->height = 4; p->gpo_count = 2;
-	break;
-      case 0x24 :  // GLK12232-25SM-Penguin
-	p->width = 20; p->height = 4; p->gpo_count = 2;
+      case 0x23 :
+      case 0x24 :
+        p->model = "GLK12232-25-SM";
+	p->width = 20; p->height = 4;
+	p->gpo_count = 2;
 	break;
       default :
 	report(RPT_ERR, "%s: unrecognized module type: 0x%02X", drvthis->name, i);
 	return -1;
     }
+    report(RPT_INFO, "%s: Model identified by byte: 0x%02X; size: %ix%i",
+    		drvthis->name, i, p->width, p->height);
   }
 
   p->framebuf = malloc(p->width * p->height);
-  p->screen_contents = malloc(p->width * p->height);
+  p->backingstore = malloc(p->width * p->height);
 
-  if (p->framebuf == NULL || p->screen_contents == NULL) {
+  if (p->framebuf == NULL || p->backingstore == NULL) {
     report(RPT_ERR, "%s: Unable to allocate memory for screen buffers", drvthis->name);
     glk_close(drvthis);
     return -1;
@@ -193,19 +219,19 @@ glk_init(Driver *drvthis)
   memset(p->framebuf, ' ', p->width * p->height);
 
 //  glk_clear();
-//  glkputl(p->PortFD, GLKCommand, 0x58, EOF);
+  glkputl(p->fd, GLKCommand, 0x58, EOF);
 
 
   // Enable flow control
-  glkflow(p->PortFD, 40, 2);
+  glkflow(p->fd, 40, 2);
 
   // Set read character timeout to 0
-  glktimeout(p->PortFD, 0);
+  glktimeout(p->fd, 0);
 
   // Enable auto-transmit of up/down key events
   // This allows us to generate REPEAT keys distinct from
   //   normal keys using timeouts.  (see glk_get_key)
-  glkputl(p->PortFD, GLKCommand, 0x7e, 1, GLKCommand, 0x41, EOF);
+  glkputl(p->fd, GLKCommand, 0x7e, 1, GLKCommand, 0x41, EOF);
 
   // Set p->contrast
   glk_set_contrast(drvthis, p->contrast);
@@ -222,21 +248,23 @@ glk_init(Driver *drvthis)
 MODULE_EXPORT void
 glk_close(Driver *drvthis)
 {
-  PrivateData *p = drvthis->private_data;
+	PrivateData *p = drvthis->private_data;
 
-  if (p != NULL) {
-    if (p->PortFD != NULL)
-      glkclose(p->PortFD);
+	if (p != NULL) {
+		if (p->fd != NULL)
+			glkclose(p->fd);
 
-    if (p->framebuf != NULL)
-      free(p->framebuf);
+		if (p->framebuf != NULL)
+			free(p->framebuf);
+		p->framebuf = NULL;  
 
-    if (p->screen_contents != NULL)
-      free(p->screen_contents);
+		if (p->backingstore != NULL)
+			free(p->backingstore);
+		p->backingstore = NULL;  
 
-    free(p);
-  }
-  drvthis->store_private_ptr(drvthis, NULL);
+		free(p);
+	}
+	drvthis->store_private_ptr(drvthis, NULL);
 }
 
 
@@ -244,11 +272,11 @@ glk_close(Driver *drvthis)
 // Returns the display width
 //
 MODULE_EXPORT int
-glk_width (Driver *drvthis)
+glk_width(Driver *drvthis)
 {
-  PrivateData *p = drvthis->private_data;
+	PrivateData *p = drvthis->private_data;
 
-  return p->width;
+	return p->width;
 }
 
 
@@ -256,11 +284,11 @@ glk_width (Driver *drvthis)
 // Returns the display height
 //
 MODULE_EXPORT int
-glk_height (Driver *drvthis)
+glk_height(Driver *drvthis)
 {
-  PrivateData *p = drvthis->private_data;
+	PrivateData *p = drvthis->private_data;
 
-  return p->height;
+	return p->height;
 }
 
 
@@ -268,11 +296,11 @@ glk_height (Driver *drvthis)
 // Returns the display's cell width
 //
 MODULE_EXPORT int
-glk_cellwidth (Driver *drvthis)
+glk_cellwidth(Driver *drvthis)
 {
-  PrivateData *p = drvthis->private_data;
+	PrivateData *p = drvthis->private_data;
 
-  return p->cellwidth;
+	return p->cellwidth;
 }
 
 
@@ -280,11 +308,11 @@ glk_cellwidth (Driver *drvthis)
 // Returns the display's cell height
 //
 MODULE_EXPORT int
-glk_cellheight (Driver *drvthis)
+glk_cellheight(Driver *drvthis)
 {
-  PrivateData *p = drvthis->private_data;
+	PrivateData *p = drvthis->private_data;
 
-  return p->cellheight;
+	return p->cellheight;
 }
 
 
@@ -295,22 +323,24 @@ glk_cellheight (Driver *drvthis)
 
 void glk_clear_forced(Driver *drvthis)
 {
-  PrivateData *p = drvthis->private_data;
+	PrivateData *p = drvthis->private_data;
 
-  p->clearcount = CLEARCOUNT;
-  glkputl(p->PortFD, GLKCommand, 0x58, EOF);
-  memset(p->screen_contents, ' ', p->width * p->height);
+	p->clearcount = CLEARCOUNT;
+	glkputl(p->fd, GLKCommand, 0x58, EOF);
+	memset(p->backingstore, ' ', p->width * p->height);
 }
 
 
 MODULE_EXPORT void
 glk_clear(Driver *drvthis)
 {
-  PrivateData *p = drvthis->private_data;
+	PrivateData *p = drvthis->private_data;
 
-  memset(p->framebuf, ' ', p->width * p->height);
-  if (--p->clearcount < 0)
-    glk_clear_forced(drvthis);
+	memset(p->framebuf, ' ', p->width * p->height);
+
+	// do a hardware clear very CLEARCOUNT invocation
+	if (--p->clearcount < 0)
+		glk_clear_forced(drvthis);
 }
 
 
@@ -324,9 +354,9 @@ glk_flush(Driver *drvthis)
 
 //   puts("glk_flush()");
   unsigned char *pf = p->framebuf;
-  unsigned char *qf = p->screen_contents;
+  unsigned char *qf = p->backingstore;
   int x, y;
-  unsigned char *ps= NULL;
+  unsigned char *ps = NULL;
 
   debug(RPT_DEBUG, "flush()");
 
@@ -336,24 +366,25 @@ glk_flush(Driver *drvthis)
     for (x = 0; x < p->width; ++x) {
       if ((*qf == *pf) && (xs >= 0)) {
         /* Write accumulated string */
-        glkputl(p->PortFD, GLKCommand, 0x79, xs * 6 + 1, y * 8, EOF);
-        glkputa(p->PortFD, x - xs, ps);
+        glkputl(p->fd, GLKCommand, 0x79, xs * p->cellwidth + 1, y * p->cellheight, EOF);
+        glkputa(p->fd, x - xs, ps);
         debug(RPT_DEBUG, "flush: Writing at (%d,%d) for %d", xs, y, x - xs);
         xs = -1;
-      } else if ((*qf != *pf) && (xs < 0)) {
+      }
+      else if ((*qf != *pf) && (xs < 0)) {
         /* Start new string of changes */
         ps = pf;
         xs = x;
       }
-      *qf++ = *pf++;  /* Update screen_contents from framebuf */
+      *qf++ = *pf++;  /* Update p->backingstore from p->framebuf */
     }
     if (xs >= 0) {
       /* Write accumulated line */
-      glkputl(p->PortFD, GLKCommand, 0x79, xs * 6 + 1, y * 8, EOF);
-      glkputa(p->PortFD, p->width - xs, ps);
+      glkputl(p->fd, GLKCommand, 0x79, xs * p->cellwidth + 1, y * p->cellheight, EOF);
+      glkputa(p->fd, p->width - xs, ps);
       debug(RPT_DEBUG, "flush: Writing at (%d,%d) for %d", xs, y, p->width - xs);
     }
-  }  /* For y */
+  }
 }
 
 
@@ -364,17 +395,17 @@ glk_flush(Driver *drvthis)
 MODULE_EXPORT void
 glk_string(Driver *drvthis, int x, int y, char string[])
 {
-  PrivateData *p = drvthis->private_data;
-  char *s;
+	PrivateData *p = drvthis->private_data;
+	char *s;
 
-  debug(RPT_DEBUG, "glk_string(%d, %d, \"%s\")", x, y, string);
+	debug(RPT_DEBUG, "glk_string(%d, %d, \"%s\")", x, y, string);
 
-  if ((y <= 0) || (y > p->height))
-     return;
+	if ((y <= 0) || (y > p->height))
+		return;
 
-  for (s = string; (*s != '\0') && (x <= p->width); s++, x++) {
-    glk_chr(drvthis, x, y, *s);
-  }
+	for (s = string; (*s != '\0') && (x <= p->width); s++, x++) {
+		glk_chr(drvthis, x, y, *s);
+	}
 }
 
 
@@ -385,37 +416,37 @@ glk_string(Driver *drvthis, int x, int y, char string[])
 MODULE_EXPORT void
 glk_chr(Driver *drvthis, int x, int y, char c)
 {
-  PrivateData *p = drvthis->private_data;
-  int  myc = (unsigned char) c;
+	PrivateData *p = drvthis->private_data;
+	int  myc = (unsigned char) c;
 
-  x--;  // Convert 1-based coords to 0-based...
-  y--;
+	x--;  // Convert 1-based coords to 0-based...
+	y--;
 
-  if (p->fontselected != 2) {
-    debug(RPT_DEBUG, "Switching to font 2");
-    /* Select font 2 */
-    glkputl(p->PortFD, GLKCommand, 0x31, 2, EOF);
-    p->fontselected = 2;
-    /* Set font metrics */
-    glkputl(p->PortFD, GLKCommand, 0x32, 1, 0, 1, 1, 32, EOF);
-    /* Clear the screen */
-    glk_clear_forced(drvthis);
-  }
+	if (p->fontselected != 1) {
+		debug(RPT_DEBUG, "Switching to font 1");
+		/* Select font 2 */
+		glkputl(p->fd, GLKCommand, 0x31, 1, EOF);
+		p->fontselected = 1;
+		/* Set font metrics */
+		glkputl(p->fd, GLKCommand, 0x32, 1, 0, 0, 0, 32, EOF);
+		/* Clear the screen */
+		glk_clear_forced(drvthis);
+	}
 
-  if ((myc >= 0) && (myc <= 15)) {
-    /* CGRAM */
-    debug(RPT_DEBUG, "CGRAM changing %d => %d", myc, p->CGRAM[myc & 7]);
-    myc = p->CGRAM[myc & 7];
-  } else if ((myc == 255) || (myc == -1)) {
-    /* Solid block */
-    myc = 133;
-  } else if (((myc > 15) && (myc < 32)) || (myc > 143)) {
-    debug(RPT_DEBUG, "Attempt to write %d to (%d,%d)", myc, x, y);
-    myc = 133;
-  }
+	if ((myc >= 0) && (myc <= 15)) {
+		/* CGRAM */
+		debug(RPT_DEBUG, "CGRAM changing %d => %d", myc, p->CGRAM[myc & 7]);
+		myc = p->CGRAM[myc & 7];
+	} else if ((myc == 255) || (myc == -1)) {
+		/* Solid block */
+		myc = 133;
+	} else if (((myc > 15) && (myc < 32)) || (myc > 143)) {
+		debug(RPT_DEBUG, "Attempt to write %d to (%d,%d)", myc, x, y);
+		myc = 133;
+	}
 
-  if ((x >= 0) && (y >= 0) && (x < p->width) && (y < p->height))
-    p->framebuf[(y * p->width) + x] = myc;
+	if ((x >= 0) && (y >= 0) && (x < p->width) && (y < p->height))
+		p->framebuf[(y * p->width) + x] = myc;
 }
 
 
@@ -428,9 +459,9 @@ glk_chr(Driver *drvthis, int x, int y, char c)
 MODULE_EXPORT int
 glk_get_contrast(Driver *drvthis)
 {
-  PrivateData *p = drvthis->private_data;
+	PrivateData *p = drvthis->private_data;
 
-  return p->contrast;
+	return p->contrast;
 }
 
 
@@ -441,181 +472,205 @@ glk_get_contrast(Driver *drvthis)
 MODULE_EXPORT void
 glk_set_contrast(Driver *drvthis, int promille)
 {
-  PrivateData *p = drvthis->private_data;
+	PrivateData *p = drvthis->private_data;
 
-  // Check it
-  if ((promille < 0) || (promille > 1000))
-    return;
+	// Check it
+	if ((promille < 0) || (promille > 1000))
+		return;
 
-  // Store it
-  p->contrast = promille;
+	// Store it
+	p->contrast = promille;
 
-  // Do it: map logical [0, 1000] -> physical [0, 255] for the hardware
-  debug(RPT_DEBUG, "Contrast: %d", p->contrast);
-  glkputl(p->PortFD, GLKCommand, 0x50, (int) ((long) promille * 255 / 1000), EOF);
+	// Do it: map logical [0, 1000] -> physical [0, 255] for the hardware
+	debug(RPT_DEBUG, "Contrast: %d", p->contrast);
+	glkputl(p->fd, GLKCommand, 0x50, (int) ((long) promille * 255 / 1000), EOF);
 }
 
+
 //////////////////////////////////////////////////////////////////////
 // Turns the lcd backlight on or off...
 //
 MODULE_EXPORT void
 glk_backlight(Driver *drvthis, int on)
 {
-  PrivateData *p = drvthis->private_data;
+	PrivateData *p = drvthis->private_data;
 
-  if (on) {
-    debug(RPT_DEBUG, "Backlight ON");
-    glkputl(p->PortFD, GLKCommand, 0x42, 0, EOF);
-  }
-  else {
-    debug(RPT_DEBUG, "Backlight OFF");
-    glkputl(p->PortFD, GLKCommand, 0x46, EOF);
-  }
+	if (on) {
+		debug(RPT_DEBUG, "Backlight ON");
+		glkputl(p->fd, GLKCommand, 0x42, 0, EOF);
+	}
+	else {
+		debug(RPT_DEBUG, "Backlight OFF");
+		glkputl(p->fd, GLKCommand, 0x46, EOF);
+	}
 }
 
+
 //////////////////////////////////////////////////////////////////////
 // Sets general purpose outputs on or off
 MODULE_EXPORT void
 glk_output(Driver *drvthis, int on)
 {
-  PrivateData *p = drvthis->private_data;
+	PrivateData *p = drvthis->private_data;
 
-  if (p->gpo_count < 2) {
-    glkputl(p->PortFD, GLKCommand, ((on) ? 'W' : 'V'), EOF);
-  }
-  else {
-    int  i;
+	if (p->gpo_count < 2) {
+    		glkputl(p->fd, GLKCommand, ((on) ? 'W' : 'V'), EOF);
+	}
+	else {
+		int  i;
 
-    for (i = 1; i <= p->gpo_count; ++i, on >>= 1) {
-      glkputl(p->PortFD, GLKCommand, ((on & 1) ? 'W' : 'V'), i, EOF);
-    }
-  }
+		for (i = 1; i <= p->gpo_count; ++i, on >>= 1) {
+			glkputl(p->fd, GLKCommand, ((on & 1) ? 'W' : 'V'), i, EOF);
+		}
+	}
 }
 
-//////////////////////////////////////////////////////////////////////
-// Tells the driver to get ready for vertical bargraphs.
-//
-static void
-glk_init_vbar(Driver *drvthis)
-{
-  //PrivateData *p = drvthis->private_data;
 
-  debug(RPT_DEBUG, "glk_init_vbar()");
-}
-
-//////////////////////////////////////////////////////////////////////
-// Tells the driver to get ready for horizontal bargraphs.
-//
-static void
-glk_init_hbar(Driver *drvthis)
-{
-  //PrivateData *p = drvthis->private_data;
-
-  debug(RPT_DEBUG, "glk_init_hbar()");
-}
-
-//////////////////////////////////////////////////////////////////////
-// Draws a big (4-row) number.
-//
+/**
+ * Write a big number to the screen.
+ * \param drvthis  Pointer to driver structure.
+ * \param x        Horizontal character position (column).
+ * \param num      Character to write (0 - 10 with 10 representing ':')
+ */
 MODULE_EXPORT void
-glk_num(Driver *drvthis, int x, int num)
+IOWarrior_num(Driver *drvthis, int x, int num)
 {
-  PrivateData *p = drvthis->private_data;
+	//PrivateData *p = drvthis->private_data;
+	int do_init = 1;
 
-  debug(RPT_DEBUG, "glk_num(%d, %d)", x, num);
+	debug(RPT_DEBUG, "glk_num(%d, %d)", x, num);
 
-  if ((num < 0) || (num > 10))
-      return;
+	if ((num < 0) || (num > 10))
+		return;
 
-  if (p->fontselected != 3) {
-    debug(RPT_DEBUG, "Switching to font 3");
-    /* Select Big Numbers font */
-    glkputl(p->PortFD, GLKCommand, 0x31, 3, EOF);
-    p->fontselected = 3;
-    /* Set font metrics */
-    glkputl(p->PortFD, GLKCommand, 0x32, 1, 0, 1, 1, 32, EOF);
-    /* Clear the screen */
-    glk_clear_forced(drvthis);
-  }
+	/* no need to check for alternative ccmodes: we have no custom characters
+	if (p->ccmode != bignum) {
+		if (p->ccmode != standard) {
+			// Not supported (yet)
+			report(RPT_WARNING, "%s: num: cannot combine two modes using user-defined characters",
+					drvthis->name);
+			return;
+		}
 
-  if ((x > 0) && (x <= p->width))
-    p->framebuf[x-1] = (num >= 10) ? ':' : (num + '0');
+		p->ccmode = bignum;
+
+		do_init = 1;
+	}
+	*/
+
+	// Lib_adv_bignum does everything needed to show the bignumbers.
+	lib_adv_bignum(drvthis, x, num, 0, do_init);
+
+	/* previous implementation using alternative font:
+	if (p->fontselected != 3) {
+		debug(RPT_DEBUG, "Switching to font 3");
+		// Select Big Numbers font
+		glkputl(p->fd, GLKCommand, 0x31, 3, EOF);
+		p->fontselected = 3;
+		// Set font metrics
+		glkputl(p->fd, GLKCommand, 0x32, 1, 0, 1, 1, 32, EOF);
+		// Clear the screen
+		glk_clear_forced(drvthis);
+	}
+
+	if ((x > 0) && (x <= p->width))
+		p->framebuf[x-1] = (num >= 10) ? ':' : (num + '0');
+	*/	
 }
 
+
+/**
+ * Get number of custom characters available.
+ * \param drvthis  Pointer to driver structure.
+ * \return  Number of custom characters (always 0).
+ */
+MODULE_EXPORT int
+glk_get_free_chars(Driver *drvthis)
+{
+	//PrivateData *p = drvthis->private_data;
+
+	debug(RPT_DEBUG, "glk_get_free_chars()");
+
+	return 0;
+}
+
+
 //////////////////////////////////////////////////////////////////////
 // Changes the font data of character n.
 //
 MODULE_EXPORT void
 glk_set_char(Driver *drvthis, int n, char *dat)
 {
-  //PrivateData *p = drvthis->private_data;
+	//PrivateData *p = drvthis->private_data;
 
-  debug(RPT_DEBUG, "glk_set_char(%d)", n);
+	debug(RPT_DEBUG, "glk_set_char(%d)", n);
 }
 
+
 /////////////////////////////////////////////////////////////////
 // Draws a vertical bar, from the bottom of the screen up.
 //
 MODULE_EXPORT void
 glk_old_vbar(Driver *drvthis, int x, int len)
 {
-  PrivateData *p = drvthis->private_data;
-  int y = p->height;
+	PrivateData *p = drvthis->private_data;
+	int y = p->height;
 
-  debug(RPT_DEBUG, "glk_old_vbar(%d, %d)", x, len);
+	debug(RPT_DEBUG, "glk_old_vbar(%d, %d)", x, len);
 
-  while (len > p->cellheight) {
-    glk_chr(drvthis, x, y, 255);
-    --y;
-    len -= p->cellheight;
-  }
+	while (len > p->cellheight) {
+		glk_chr(drvthis, x, y, 255);
+		--y;
+		len -= p->cellheight;
+	}
 
-  if (y >= 0) {
-    int lastc;
+	if (y >= 0) {
+		int lastc;
 
-    switch (len) {
-      case 0 :  return; break;  /* Don't output a char */
-      case 1 :  lastc = 138; break;  /* One bar */
-      case 2 :  lastc = 139; break;
-      case 3 :  lastc = 140; break;
-      case 4 :  lastc = 141; break;
-      case 5 :  lastc = 142; break;
-      case 6 :  lastc = 143; break;
-      default:  lastc = 133; break;
-    }
-    glk_chr(drvthis, x, y, lastc);
-  }
+		switch (len) {
+			case 0 :  return; break;  /* Don't output a char */
+			case 1 :  lastc = 138; break;  /* One bar */
+			case 2 :  lastc = 139; break;
+			case 3 :  lastc = 140; break;
+			case 4 :  lastc = 141; break;
+			case 5 :  lastc = 142; break;
+			case 6 :  lastc = 143; break;
+			default:  lastc = 133; break;
+		}
+		glk_chr(drvthis, x, y, lastc);
+	}
 }
 
+
 /////////////////////////////////////////////////////////////////
 // Draws a horizontal bar to the right.
 //
 MODULE_EXPORT void
 glk_old_hbar(Driver *drvthis, int x, int y, int len)
 {
-  PrivateData *p = drvthis->private_data;
+	PrivateData *p = drvthis->private_data;
 
-  debug(RPT_DEBUG, "glk_old_hbar(%d, %d, %d)", x, y, len);
+	debug(RPT_DEBUG, "glk_old_hbar(%d, %d, %d)", x, y, len);
 
-  while (len > p->cellwidth) {
-    glk_chr(drvthis, x, y, 255);
-    ++x;
-    len -= p->cellwidth;
-  }
+	while (len > p->cellwidth) {
+		glk_chr(drvthis, x, y, 255);
+		++x;
+		len -= p->cellwidth;
+	}
 
-  if (x <= p->width) {
-    int lastc;
+	if (x <= p->width) {
+		int lastc;
 
-    switch (len) {
-      case 0 :  lastc = ' '; break;
-      case 1 :  lastc = 134; break;  /* One bar */
-      case 2 :  lastc = 135; break;
-      case 3 :  lastc = 136; break;
-      case 4 :  lastc = 137; break;
-      default:  lastc = 133; break;
-    }
-    glk_chr(drvthis, x, y, lastc);
-  }
+		switch (len) {
+			case 0 :  lastc = ' '; break;
+			case 1 :  lastc = 134; break;  /* One bar */
+			case 2 :  lastc = 135; break;
+			case 3 :  lastc = 136; break;
+			case 4 :  lastc = 137; break;
+			default:  lastc = 133; break;
+		}
+		glk_chr(drvthis, x, y, lastc);
+	}
 }
 
 
@@ -631,7 +686,7 @@ glk_old_icon(Driver *drvthis, int which, int dest)
   PrivateData *p = drvthis->private_data;
   unsigned char old, new;
   unsigned char *pf = p->framebuf;
-  unsigned char *qf = p->screen_contents;
+  unsigned char *qf = p->backingstore;
   int count;
 
   debug(RPT_DEBUG, "glk_old_icon(%i, %i)", which, dest);
@@ -658,7 +713,7 @@ glk_old_icon(Driver *drvthis, int which, int dest)
   /* Replace all old icons with new icon in new frame */
   for (count = p->width * p->height; count > 0; count--) {
     if (*qf == old) {
-      debug(RPT_DEBUG, "icon %d to %d at %d", old, new, qf - p->screen_contents);
+      debug(RPT_DEBUG, "icon %d to %d at %d", old, new, qf - p->backingstore);
       *pf = new;
     }
     ++qf; ++pf;
@@ -683,19 +738,21 @@ glk_get_key(Driver *drvthis)
 
   debug(RPT_DEBUG, "glk_get_key()");
 
-  c = glkgetc(p->PortFD);
+  c = glkgetc(p->fd);
 
   if ((c >= 'A') && (c <= 'Z')) {
     /* Key down event */
     keycode = c;
     gettimeofday(&lastkey, NULL);
     debug(RPT_DEBUG, "KEY %c at %ld.%06ld", c, lastkey.tv_sec, lastkey.tv_usec);
-  } else if ((c >= 'a') && (c <= 'z')) {
+  }
+  else if ((c >= 'a') && (c <= 'z')) {
     /* Key up event */
     debug(RPT_DEBUG, "KEY %c UP", c);
     keycode = -1;
     c = 0;
-  } else {
+  }
+  else {
     /* Assume timeout */
     c = 0;
     if (keycode > 0) {
@@ -744,3 +801,5 @@ glk_get_key(Driver *drvthis)
 
   return key;
 }
+
+/* EOF */
diff --git a/server/drivers/glk.h b/server/drivers/glk.h
index 6c07667..2f8a57d 100644
--- a/server/drivers/glk.h
+++ b/server/drivers/glk.h
@@ -19,6 +19,7 @@ MODULE_EXPORT void glk_old_hbar(Driver *drvthis, int x, int y, int len);
 MODULE_EXPORT void glk_num(Driver *drvthis, int x, int num);
 MODULE_EXPORT void glk_old_icon(Driver *drvthis, int which, int dest);
 
+MODULE_EXPORT int  glk_get_free_chars(Driver *drvthis);
 MODULE_EXPORT void glk_set_char(Driver *drvthis, int n, char *dat);
 
 MODULE_EXPORT int glk_get_contrast(Driver *drvthis);
diff --git a/server/drivers/glkproto.c b/server/drivers/glkproto.c
index 4dffec0..274b179 100644
--- a/server/drivers/glkproto.c
+++ b/server/drivers/glkproto.c
@@ -55,6 +55,7 @@ GLKDisplay *glkopen(char *name, tcflag_t speed)
    /* Get current settings */
    if (tcgetattr(fd, &new) < 0) {
       int errsave = errno;
+
       close(fd);
       errno = errsave;
       return(NULL);
@@ -99,6 +100,7 @@ GLKDisplay *glkopen(char *name, tcflag_t speed)
    tcflush(fd, TCIOFLUSH);
    if (tcsetattr(fd, TCSANOW, &new) < 0) {
       int errsave = errno;
+
       glkclose(retval);
       errno = errsave;
       return(NULL);
@@ -438,19 +440,19 @@ glkputl(GLKDisplay *fd, ...)
       retval = glkput(fd, value);
       value = va_arg(ap, int);
    }
+   va_end(ap);
 
    return(retval);
 }
 
 /* glkputs
  *
- * Send a null terminated string of characters to the
- *    GLK.
+ * Send a null terminated string of characters to the GLK.
  */
 int
 glkputs(GLKDisplay *fd, char *str)
 {
-   register  char *p = str;
+   register char *p = str;
    int retval;
 
    retval = 0;  /* Success */
@@ -468,7 +470,7 @@ glkputs(GLKDisplay *fd, char *str)
 int
 glkputa(GLKDisplay *fd, int len, unsigned char *str)
 {
-   register  unsigned char *p = str;
+   register unsigned char *p = str;
    int i;
    int retval;