root/branches/volker_dev/drv_HD44780.c

/* $Id$
 * $URL$
 *
 * new style driver for HD44780-based displays
 *
 * Copyright (C) 2003 Michael Reinelt <reinelt@eunet.at>
 * Copyright (C) 2004 The LCD4Linux Team <lcd4linux-devel@users.sourceforge.net>
 *
 * Support for I2C bus
 * Copyright (C) 2005 Luis Correia <lfcorreia@users.sf.net>
 *
 * Modification for 4-Bit mode
 * Copyright (C) 2003 Martin Hejl (martin@hejl.de)
 *
 * Modification for 2nd controller support
 * Copyright (C) 2003 Jesse Brook Kovach <jkovach@wam.umd.edu>
 *
 * This file is part of LCD4Linux.
 *
 * LCD4Linux is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * LCD4Linux is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */

/* 
 *
 * exported fuctions:
 *
 * struct DRIVER drv_HD44780
 *
 */

#include "config.h"

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <termios.h>
#include <fcntl.h>
#include <sys/time.h>
#include <sys/ioctl.h>

#include "debug.h"
#include "cfg.h"
#include "udelay.h"
#include "qprintf.h"
#include "timer.h"
#include "plugin.h"
#include "widget.h"
#include "widget_text.h"
#include "widget_icon.h"
#include "widget_bar.h"
#include "drv.h"
#include "drv_generic_text.h"
#include "drv_generic_gpio.h"

#ifdef WITH_PARPORT
#include "drv_generic_parport.h"
#endif

#ifdef WITH_I2C
#include "drv_generic_i2c.h"
#endif

static char Name[] = "HD44780";

static int Bus;
static int Model;
static int Capabilities;


/* Timings */
#ifdef WITH_PARPORT
static int T_CY, T_PW, T_AS, T_AH;
#endif
static int T_INIT1, T_INIT2, T_EXEC, T_WRCG, T_CLEAR, T_HOME, T_ONOFF;
#ifdef WITH_PARPORT
static int T_POWER, T_GPO_ST, T_GPO_PW;
#endif

static int Bits = 0;
static int numControllers = 0;
static int allControllers = 0;
static int currController = 0;

/* size of every single controller */
static int CROWS[4];
static int CCOLS[4];

static unsigned char SIGNAL_RW;
static unsigned char SIGNAL_RS;
static unsigned char SIGNAL_ENABLE;
static unsigned char SIGNAL_ENABLE2;
static unsigned char SIGNAL_ENABLE3;
static unsigned char SIGNAL_ENABLE4;

static unsigned char SIGNAL_GPO;
#ifdef WITH_PARPORT
static unsigned char SIGNAL_BACKLIGHT;
static unsigned char SIGNAL_POWER;
#endif

/* maximum time to wait for the busy-flag (in usec) */
#define MAX_BUSYFLAG_WAIT 10000

/* maximum busy flag errors before falling back to busy-waiting */
#define MAX_BUSYFLAG_ERRORS 20

/* flag for busy-waiting vs. busy flag checking */
#ifdef WITH_PARPORT
static int UseBusy = 0;
#endif

/* buffer holding the GPO state */
#ifdef WITH_PARPORT
static unsigned char GPO = 0;
#endif

typedef struct {
    int type;
    char *name;
    int capabilities;
} MODEL;

#define CAP_PARPORT    (1<<0)
#define CAP_I2C        (1<<1)
#define CAP_GPO        (1<<2)
#define CAP_BACKLIGHT  (1<<3)
#define CAP_BRIGHTNESS (1<<4)
#define CAP_BUSY4BIT   (1<<5)
#define CAP_HD66712    (1<<6)
#define CAP_LCM162     (1<<7)

#define BUS_PP  CAP_PARPORT
#define BUS_I2C CAP_I2C


static MODEL Models[] = {
    {0x01, "generic", CAP_PARPORT | CAP_I2C | CAP_GPO | CAP_BACKLIGHT},
    {0x02, "Noritake", CAP_PARPORT | CAP_I2C | CAP_GPO | CAP_BRIGHTNESS},
    {0x03, "Soekris", CAP_PARPORT | CAP_BUSY4BIT},
    {0x04, "HD66712", CAP_PARPORT | CAP_I2C | CAP_GPO | CAP_BACKLIGHT | CAP_HD66712},
    {0x05, "LCM-162", CAP_PARPORT | CAP_LCM162},
    {0xff, "Unknown", 0}
};


/****************************************/
/***  generic functions               ***/
/****************************************/

static int (*drv_HD_load) (const char *section);
static void (*drv_HD_command) (const unsigned char controller, const unsigned char cmd, const unsigned long delay);
static void (*drv_HD_data) (const unsigned char controller, const char *string, const int len,
          const unsigned long delay);
static void (*drv_HD_stop) (void);



/****************************************/
/***  parport dependant functions     ***/
/****************************************/

#ifdef WITH_PARPORT

static void drv_HD_PP_busy(const int controller)
{
    static unsigned int errors = 0;

    unsigned char enable;
    unsigned char data = 0xFF;
    unsigned char busymask;
    unsigned char ctrlmask;
    unsigned int counter;

    if (Bits == 8) {
  busymask = 0x80;
    } else {
  /* Since in 4-Bit mode DB0 on the parport is mapped to DB4 on the LCD
   * (and consequently, DB3 on the partport is mapped to DB7 on the LCD)
   * we need to listen for DB3 on the parport to go low
   */
  busymask = 0x08;
    }

    ctrlmask = 0x08;
    while (ctrlmask > 0) {

  if (controller & ctrlmask) {

      enable = 0;
      if (ctrlmask & 0x01)
    enable = SIGNAL_ENABLE;
      else if (ctrlmask & 0x02)
    enable = SIGNAL_ENABLE2;
      else if (ctrlmask & 0x04)
    enable = SIGNAL_ENABLE3;
      else if (ctrlmask & 0x08)
    enable = SIGNAL_ENABLE4;

      /* set data-lines to input */
      drv_generic_parport_direction(1);

      if (Bits == 8) {
    /* Set RW, clear RS */
    drv_generic_parport_control(SIGNAL_RW | SIGNAL_RS, SIGNAL_RW);
      } else {
    drv_generic_parport_data(SIGNAL_RW);
      }

      /* Address set-up time */
      ndelay(T_AS);

      /* rise ENABLE */
      if (Bits == 8) {
    drv_generic_parport_control(enable, enable);
      } else {
    drv_generic_parport_data(SIGNAL_RW | enable);
      }

      counter = 0;
      while (1) {
    /* read the busy flag */
    data = drv_generic_parport_read();
    if ((data & busymask) == 0) {
        errors = 0;
        break;
    }

    /* make sure we don't wait forever
     * - but only check after 5 iterations
     * that way, we won't slow down normal mode
     * (where we don't need the timeout anyway) 
     */
    counter++;

    if (counter >= 5) {
        struct timeval now, end;

        if (counter == 5) {
      /* determine the time when the timeout has expired */
      gettimeofday(&end, NULL);
      end.tv_usec += MAX_BUSYFLAG_WAIT;
      while (end.tv_usec > 1000000) {
          end.tv_usec -= 1000000;
          end.tv_sec++;
      }
        }

        /* get the current time */
        gettimeofday(&now, NULL);
        if (now.tv_sec == end.tv_sec ? now.tv_usec >= end.tv_usec : now.tv_sec >= end.tv_sec) {
      error("%s: timeout waiting for busy flag on controller %x (0x%02x)", Name, ctrlmask, data);
      if (++errors >= MAX_BUSYFLAG_ERRORS) {
          error("%s: too many busy flag failures, turning off busy flag checking.", Name);
          UseBusy = 0;
      }
      break;
        }
    }
      }

      /* RS=low, RW=low, EN=low */
      if (Bits == 8) {
    /* Lower EN */
    drv_generic_parport_control(enable, 0);

    /* Address hold time */
    ndelay(T_AH);

    drv_generic_parport_control(SIGNAL_RW | SIGNAL_RS, 0);
      } else {
    /* Lower EN */
    drv_generic_parport_data(SIGNAL_RW);
    ndelay(T_AH);
    drv_generic_parport_data(0);
      }

      /* set data-lines to output */
      drv_generic_parport_direction(0);
  }
  ctrlmask >>= 1;
    }
}


static void drv_HD_PP_nibble(const unsigned char controller, const unsigned char nibble)
{
    unsigned char enable;

    /* enable signal: 'controller' is a bitmask */
    /* bit n .. send to controller #n */
    /* so we can send a byte to more controllers at the same time! */
    enable = 0;
    if (controller & 0x01)
  enable |= SIGNAL_ENABLE;
    if (controller & 0x02)
  enable |= SIGNAL_ENABLE2;
    if (controller & 0x04)
  enable |= SIGNAL_ENABLE3;
    if (controller & 0x08)
  enable |= SIGNAL_ENABLE4;

    /* clear ENABLE */
    /* put data on DB1..DB4 */
    /* nibble already contains RS bit! */
    drv_generic_parport_data(nibble);

    /* Address set-up time */
    ndelay(T_AS);

    /* rise ENABLE */
    drv_generic_parport_data(nibble | enable);

    /* Enable pulse width */
    ndelay(T_PW);

    /* lower ENABLE */
    drv_generic_parport_data(nibble);
}


static void drv_HD_PP_byte(const unsigned char controller, const unsigned char data, const unsigned char RS)
{
    /* send high nibble of the data */
    drv_HD_PP_nibble(controller, ((data >> 4) & 0x0f) | RS);

    /* Make sure we honour T_CY */
    ndelay(T_CY - T_AS - T_PW);

    /* send low nibble of the data */
    drv_HD_PP_nibble(controller, (data & 0x0f) | RS);
}


static void drv_HD_PP_command(const unsigned char controller, const unsigned char cmd, const unsigned long delay)
{
    unsigned char enable;

    if (UseBusy)
  drv_HD_PP_busy(controller);

    if (Bits == 8) {

  /* enable signal: 'controller' is a bitmask */
  /* bit n .. send to controller #n */
  /* so we can send a byte to more controllers at the same time! */
  enable = 0;
  if (controller & 0x01)
      enable |= SIGNAL_ENABLE;
  if (controller & 0x02)
      enable |= SIGNAL_ENABLE2;
  if (controller & 0x04)
      enable |= SIGNAL_ENABLE3;
  if (controller & 0x08)
      enable |= SIGNAL_ENABLE4;

  /* put data on DB1..DB8 */
  drv_generic_parport_data(cmd);

  /* clear RW and RS */
  drv_generic_parport_control(SIGNAL_RW | SIGNAL_RS, 0);

  /* Address set-up time */
  ndelay(T_AS);

  /* send command */
  drv_generic_parport_toggle(enable, 1, T_PW);

    } else {

  drv_HD_PP_byte(controller, cmd, 0);

    }

    /* wait for command completion */
    if (!UseBusy)
  udelay(delay);

}


static void drv_HD_PP_data(const unsigned char controller, const char *string, const int len, const unsigned long delay)
{
    int l = len;
    unsigned char enable;

    /* sanity check */
    if (len <= 0)
  return;

    if (Bits == 8) {

  /* enable signal: 'controller' is a bitmask */
  /* bit n .. send to controller #n */
  /* so we can send a byte to more controllers at the same time! */
  enable = 0;
  if (controller & 0x01)
      enable |= SIGNAL_ENABLE;
  if (controller & 0x02)
      enable |= SIGNAL_ENABLE2;
  if (controller & 0x04)
      enable |= SIGNAL_ENABLE3;
  if (controller & 0x08)
      enable |= SIGNAL_ENABLE4;

  if (!UseBusy) {
      /* clear RW, set RS */
      drv_generic_parport_control(SIGNAL_RW | SIGNAL_RS, SIGNAL_RS);
      /* Address set-up time */
      ndelay(T_AS);
  }

  while (l--) {

      if (UseBusy) {
    drv_HD_PP_busy(controller);
    /* clear RW, set RS */
    drv_generic_parport_control(SIGNAL_RW | SIGNAL_RS, SIGNAL_RS);
    /* Address set-up time */
    ndelay(T_AS);
      }

      /* put data on DB1..DB8 */
      drv_generic_parport_data(*(string++));

      /* send command */
      drv_generic_parport_toggle(enable, 1, T_PW);

      /* wait for command completion */
      if (!UseBusy)
    udelay(delay);
  }

    } else {      /* 4 bit mode */

  while (l--) {
      if (UseBusy)
    drv_HD_PP_busy(controller);

      /* send data with RS enabled */
      drv_HD_PP_byte(controller, *(string++), SIGNAL_RS);

      /* wait for command completion */
      if (!UseBusy)
    udelay(delay);
  }
    }
}


static int drv_HD_PP_load(const char *section)
{
    if (cfg_number(section, "Bits", 8, 4, 8, &Bits) < 0)
  return -1;

    if (Bits != 4 && Bits != 8) {
  error("%s: bad %s.Bits '%d' from %s, should be '4' or '8'", Name, section, Bits, cfg_source());
  return -1;
    }

    /* LCM-162 only supports 8-bit-mode */
    if (Capabilities & CAP_LCM162 && Bits != 8) {
  error("%s: Model '%s' does not support %d bit mode!", Name, Models[Model].name, Bits);
  Bits = 8;
    }
    info("%s: using %d bit mode", Name, Bits);

    if (drv_generic_parport_open(section, Name) != 0) {
  error("%s: could not initialize parallel port!", Name);
  return -1;
    }

    /* Soft-Wiring */
    if (Capabilities & CAP_LCM162) {
  /* the LCM-162 is hardwired */
  if ((SIGNAL_RS = drv_generic_parport_hardwire_ctrl("RS", "SLCTIN")) == 0xff)
      return -1;
  if ((SIGNAL_RW = drv_generic_parport_hardwire_ctrl("RW", "INIT")) == 0xff)
      return -1;
  if ((SIGNAL_ENABLE = drv_generic_parport_hardwire_ctrl("ENABLE", "AUTOFD")) == 0xff)
      return -1;
  if ((SIGNAL_ENABLE2 = drv_generic_parport_hardwire_ctrl("ENABLE2", "GND")) == 0xff)
      return -1;
  if ((SIGNAL_ENABLE3 = drv_generic_parport_hardwire_ctrl("ENABLE3", "GND")) == 0xff)
      return -1;
  if ((SIGNAL_ENABLE4 = drv_generic_parport_hardwire_ctrl("ENABLE4", "GND")) == 0xff)
      return -1;
  if ((SIGNAL_BACKLIGHT = drv_generic_parport_hardwire_ctrl("BACKLIGHT", "GND")) == 0xff)
      return -1;
  if ((SIGNAL_GPO = drv_generic_parport_hardwire_ctrl("GPO", "GND")) == 0xff)
      return -1;
  if ((SIGNAL_POWER = drv_generic_parport_hardwire_ctrl("POWER", "GND")) == 0xff)
      return -1;
    } else {
  if (Bits == 8) {
      if ((SIGNAL_RS = drv_generic_parport_wire_ctrl("RS", "AUTOFD")) == 0xff)
    return -1;
      if ((SIGNAL_RW = drv_generic_parport_wire_ctrl("RW", "GND")) == 0xff)
    return -1;
      if ((SIGNAL_ENABLE = drv_generic_parport_wire_ctrl("ENABLE", "STROBE")) == 0xff)
    return -1;
      if ((SIGNAL_ENABLE2 = drv_generic_parport_wire_ctrl("ENABLE2", "GND")) == 0xff)
    return -1;
      if ((SIGNAL_ENABLE3 = drv_generic_parport_wire_ctrl("ENABLE3", "GND")) == 0xff)
    return -1;
      if ((SIGNAL_ENABLE4 = drv_generic_parport_wire_ctrl("ENABLE4", "GND")) == 0xff)
    return -1;
  } else {
      if ((SIGNAL_RS = drv_generic_parport_wire_data("RS", "DB4")) == 0xff)
    return -1;
      if ((SIGNAL_RW = drv_generic_parport_wire_data("RW", "DB5")) == 0xff)
    return -1;
      if ((SIGNAL_ENABLE = drv_generic_parport_wire_data("ENABLE", "DB6")) == 0xff)
    return -1;
      if ((SIGNAL_ENABLE2 = drv_generic_parport_wire_data("ENABLE2", "GND")) == 0xff)
    return -1;
      if ((SIGNAL_ENABLE3 = drv_generic_parport_wire_data("ENABLE3", "GND")) == 0xff)
    return -1;
      if ((SIGNAL_ENABLE4 = drv_generic_parport_wire_data("ENABLE4", "GND")) == 0xff)
    return -1;
  }
  /* backlight GPO and power are always control signals */
  if ((SIGNAL_BACKLIGHT = drv_generic_parport_wire_ctrl("BACKLIGHT", "GND")) == 0xff)
      return -1;
  if ((SIGNAL_GPO = drv_generic_parport_wire_ctrl("GPO", "GND")) == 0xff)
      return -1;
  if ((SIGNAL_POWER = drv_generic_parport_wire_ctrl("POWER", "GND")) == 0xff)
      return -1;
    }

    /* clear capabilities if corresponding signal is GND */
    if (SIGNAL_BACKLIGHT == 0) {
  Capabilities &= ~CAP_BACKLIGHT;
    }
    if (SIGNAL_GPO == 0) {
  Capabilities &= ~CAP_GPO;
    }

    /* Timings */

    /* low level communication timings [nanoseconds]
     * as these values differ from spec to spec,
     * we use the worst-case default values, but allow
     * modification from the config file.
     */
    T_CY = timing(Name, section, "CY", 1000, "ns"); /* Enable cycle time */
    T_PW = timing(Name, section, "PW", 450, "ns");  /* Enable pulse width */
    T_AS = timing(Name, section, "AS", 140, "ns");  /* Address setup time */
    T_AH = timing(Name, section, "AH", 20, "ns"); /* Address hold time */

    /* GPO timing */
    if (SIGNAL_GPO != 0) {
  T_GPO_ST = timing(Name, section, "GPO_ST", 20, "ns"); /* 74HCT573 set-up time */
  T_GPO_PW = timing(Name, section, "GPO_PW", 230, "ns");  /* 74HCT573 enable pulse width */
    } else {
  T_GPO_ST = 0;
  T_GPO_PW = 0;
    }

    /* HD44780 execution timings [microseconds]
     * as these values differ from spec to spec,
     * we use the worst-case default values, but allow
     * modification from the config file.
     */
    T_INIT1 = timing(Name, section, "INIT1", 4100, "us"); /* first init sequence: 4.1 msec */
    T_INIT2 = timing(Name, section, "INIT2", 100, "us");  /* second init sequence: 100 usec */
    T_EXEC = timing(Name, section, "EXEC", 80, "us"); /* normal execution time */
    T_WRCG = timing(Name, section, "WRCG", 120, "us");  /* CG RAM Write */
    T_CLEAR = timing(Name, section, "CLEAR", 2250, "us"); /* Clear Display */
    T_HOME = timing(Name, section, "HOME", 2250, "us"); /* Return Cursor Home */
    T_ONOFF = timing(Name, section, "ONOFF", 2250, "us"); /* Display On/Off Control */

    /* Power-on delay */
    if (SIGNAL_POWER != 0) {
  T_POWER = timing(Name, section, "POWER", 500, "ms");
    } else {
  T_POWER = 0;
    }

    /* clear all signals */
    if (Bits == 8) {
  drv_generic_parport_control(SIGNAL_RS | SIGNAL_RW |
            SIGNAL_ENABLE | SIGNAL_ENABLE2 | SIGNAL_ENABLE3 | SIGNAL_ENABLE4 |
            SIGNAL_BACKLIGHT | SIGNAL_GPO | SIGNAL_POWER, 0);
    } else {
  drv_generic_parport_control(SIGNAL_BACKLIGHT | SIGNAL_GPO | SIGNAL_POWER, 0);
  drv_generic_parport_data(0);
    }

    /* set direction: write */
    drv_generic_parport_direction(0);

    /* raise power pin */
    if (SIGNAL_POWER != 0) {
  drv_generic_parport_control(SIGNAL_POWER, SIGNAL_POWER);
  udelay(1000 * T_POWER);
    }

    /* initialize *all* controllers */
    if (Bits == 8) {
  drv_HD_PP_command(allControllers, 0x30, T_INIT1); /* 8 Bit mode, wait 4.1 ms */
  drv_HD_PP_command(allControllers, 0x30, T_INIT2); /* 8 Bit mode, wait 100 us */
  drv_HD_PP_command(allControllers, 0x38, T_EXEC);  /* 8 Bit mode, 1/16 duty cycle, 5x8 font */
    } else {
  drv_HD_PP_nibble(allControllers, 0x03);
  udelay(T_INIT1);  /* 4 Bit mode, wait 4.1 ms */
  drv_HD_PP_nibble(allControllers, 0x03);
  udelay(T_INIT2);  /* 4 Bit mode, wait 100 us */
  drv_HD_PP_nibble(allControllers, 0x03);
  udelay(T_INIT1);  /* 4 Bit mode, wait 4.1 ms */
  drv_HD_PP_nibble(allControllers, 0x02);
  udelay(T_INIT2);  /* 4 Bit mode, wait 100 us */
  drv_HD_PP_command(allControllers, 0x28, T_EXEC);  /* 4 Bit mode, 1/16 duty cycle, 5x8 font */
    }

    /* maybe use busy-flag from now on  */
    /* (we can't use the busy flag during the init sequence) */
    cfg_number(section, "UseBusy", 0, 0, 1, &UseBusy);

    /* make sure we don't use the busy flag with RW wired to GND */
    if (UseBusy && !SIGNAL_RW) {
  error("%s: busy-flag checking is impossible with RW wired to GND!", Name);
  UseBusy = 0;
    }

    /* make sure the display supports busy-flag checking in 4-Bit-Mode */
    /* at the moment this is inly possible with Martin Hejl's gpio driver, */
    /* which allows to use 4 bits as input and 4 bits as output */
    if (UseBusy && Bits == 4 && !(Capabilities & CAP_BUSY4BIT)) {
  error("%s: Model '%s' does not support busy-flag checking in 4 bit mode", Name, Models[Model].name);
  UseBusy = 0;
    }

    info("%s: %susing busy-flag checking", Name, UseBusy ? "" : "not ");

    /* The LCM-162 should really use BusyFlag checking */
    if (!UseBusy && (Capabilities & CAP_LCM162)) {
  error("%s: Model '%s' should definitely use busy-flag checking!", Name, Models[Model].name);
    }

    return 0;
}


static void drv_HD_PP_stop(void)
{
    /* clear all signals */
    if (Bits == 8) {
  drv_generic_parport_control(SIGNAL_RS |
            SIGNAL_RW | SIGNAL_ENABLE | SIGNAL_ENABLE2 | SIGNAL_ENABLE3 | SIGNAL_ENABLE4 |
            SIGNAL_BACKLIGHT | SIGNAL_GPO, 0);
    } else {
  drv_generic_parport_data(0);
  drv_generic_parport_control(SIGNAL_BACKLIGHT | SIGNAL_GPO | SIGNAL_POWER, 0);
    }

    drv_generic_parport_close();

}

#endif


#ifdef WITH_I2C

/****************************************/
/***  i2c dependant functions         ***/
/****************************************/

    /*
       DISCLAIMER!!!!

       The following code is WORK IN PROGRESS, since it basicly 'works for us...'

       (C) 2005 Paul Kamphuis & Luis Correia

       We have removed all of the delays from this code, as the I2C bus is slow enough...
       (maximum possible speed is 100KHz only)

     */

static void drv_HD_I2C_nibble(unsigned char controller, unsigned char nibble)
{
    unsigned char enable;
    unsigned char command;  /* this is actually the first data byte on the PCF8574 */
    unsigned char data_block[2];
    /* enable signal: 'controller' is a bitmask */
    /* bit n .. send to controller #n */
    /* so we can send a byte to more controllers at the same time! */
    enable = 0;
    if (controller & 0x01)
  enable |= SIGNAL_ENABLE;
    if (controller & 0x02)
  enable |= SIGNAL_ENABLE2;
    if (controller & 0x04)
  enable |= SIGNAL_ENABLE3;
    if (controller & 0x08)
  enable |= SIGNAL_ENABLE4;

    /*
       The new method Paul Kamphuis has concocted places the 3 needed writes to the I2C device
       as a single operation, using the 'i2c_smbus_write_block_data' function.
       These actual writes are performed by putting the nibble along with the 'EN' signal.

       command = first byte to be written, which contains the nibble (DB0..DB3)
       data [0]   = second byte to be written, which contains the nibble plus the EN signal
       data [1]   = third byte to be written, which contains the nibble (DB0..DB3)

       Then we write the block as a whole.

       The main advantage we see is that we do 2 less IOCTL's from our driver.
     */

    command = nibble;
    data_block[0] = nibble | enable;
    data_block[1] = nibble;

    drv_generic_i2c_command(command, data_block, 2);
}


static void drv_HD_I2C_byte(const unsigned char controller, const unsigned char data)
{
    /* send data with RS enabled */
    drv_HD_I2C_nibble(controller, ((data >> 4) & 0x0f) | SIGNAL_RS);
    drv_HD_I2C_nibble(controller, (data & 0x0f) | SIGNAL_RS);
}


static void drv_HD_I2C_command(const unsigned char controller, const unsigned char cmd, __attribute__ ((unused))
             const unsigned long delay)
{
    /* send data with RS disabled */
    drv_HD_I2C_nibble(controller, ((cmd >> 4) & 0x0f));
    drv_HD_I2C_nibble(controller, ((cmd) & 0x0f));
}

static void drv_HD_I2C_data(const unsigned char controller, const char *string, const int len, __attribute__ ((unused))
          const unsigned long delay)
{
    int l = len;

    /* sanity check */
    if (len <= 0)
  return;

    while (l--) {
  drv_HD_I2C_byte(controller, *(string++));
    }
}


static int drv_HD_I2C_load(const char *section)
{
    if (cfg_number(section, "Bits", 8, 4, 8, &Bits) < 0)
  return -1;
    if (Bits != 4) {
  error("%s: bad %s.Bits '%d' from %s, should be '4'", Name, section, Bits, cfg_source());
  return -1;
    }

    info("%s: using %d bit mode", Name, Bits);

    if (drv_generic_i2c_open(section, Name) != 0) {
  error("%s: could not initialize i2c attached device!", Name);
  return -1;
    }

    if ((SIGNAL_RS = drv_generic_i2c_wire