/*
 * libieee1284 - IEEE 1284 library
 * Copyright (C) 2001, 2002  Tim Waugh <twaugh@redhat.com>
 *
 * This program 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 of the License, or
 * (at your option) any later version.
 *
 * This program 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *
 * This file defines access for VDMLPT on NT kernels.  Basically a copy of 
 * access_io.c with some slight differences.
 */

#include "config.h"

#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#if !(defined __MINGW32__ || defined _MSC_VER)
#include <sys/ioctl.h>
#else
#include <sys/timeb.h> /* ftime() */
#endif
#include <sys/stat.h>
#ifndef _MSC_VER
#include <sys/time.h>
#endif
#include <sys/types.h>
#ifdef __unix__
#include <unistd.h>
#endif

#include "access.h"
#include "debug.h"
#include "default.h"
#include "delay.h"
#include "ieee1284.h"
#include "detect.h"
#include "parport.h"


#ifdef HAVE_CYGWIN_NT

#ifdef __CYGWIN__
#include <w32api/windows.h>
#else
#include <windows.h>
#endif
#include "par_nt.h"


static int
init (struct parport *pport, int flags, int *capabilities)
{ 
  struct parport_internal *port = pport->priv;

  /* Note: We can only ever provide exclusive access on NT. */
  if (flags & ~F1284_EXCL) /* silently ignore F1284_EXCL - dbjh */
    return E1284_NOTAVAIL;

  port->fd = (int)CreateFile(port->device, GENERIC_READ | GENERIC_WRITE,
    0, NULL, OPEN_EXISTING, 0, NULL);
  if (port->fd == (int)INVALID_HANDLE_VALUE) 
  {
    if (port->device != NULL) 
      debugprintf("Failed opening %s\n", port->device);
    return E1284_SYS;
  }

  if (capabilities)
  {
    *capabilities |= CAP1284_RAW;
    /* Can't do bidir mode with this port */
    *capabilities &= ~(CAP1284_ECPSWE | CAP1284_BYTE);
  }

  /* Need to write this.
   * If we find an ECP port, we can adjust some of the access function
   * pointers in io_access_functions to point to functions that use
   * hardware assistance. */

  return E1284_OK;
}

static void
cleanup (struct parport_internal *port)
{
  CloseHandle((HANDLE)(port->fd));
}

static void
write_data (struct parport_internal *port, unsigned char reg)
{
  unsigned int dummy;

  if (!(DeviceIoControl((HANDLE)(port->fd), NT_IOCTL_DATA, &reg, sizeof(reg), 
          NULL, 0, (LPDWORD)&dummy, NULL)))
      debugprintf("raw_outb: DeviceIoControl failed!\n");
}

static int
read_status (struct parport_internal *port)
{
  char ret;
  unsigned int dummy;

  if (!(DeviceIoControl((HANDLE)(port->fd), NT_IOCTL_STATUS, NULL, 0, &ret, 
          sizeof(ret), (LPDWORD)&dummy, NULL)))
      debugprintf("read_status: DeviceIoControl failed!\n");

  return debug_display_status ((unsigned char)(ret ^ S1284_INVERTED));
}

static void
raw_frob_control (struct parport_internal *port,
		  unsigned char mask,
		  unsigned char val)
{
  unsigned char ctr = port->ctr;
  unsigned char dummyc;
  unsigned int dummy;
  /* Deal with inversion issues. */
  val ^= mask & C1284_INVERTED;
  ctr = (ctr & ~mask) ^ val;
  if (!(DeviceIoControl((HANDLE)(port->fd), NT_IOCTL_CONTROL, &ctr, 
          sizeof(ctr), &dummyc, sizeof(dummyc), (LPDWORD)&dummy, NULL)))
      debugprintf("frob_control: DeviceIoControl failed!\n");
  port->ctr = ctr;
  debug_frob_control (mask, val);
}

static int
read_control (struct parport_internal *port)
{
  const unsigned char rm = (C1284_NSTROBE |
			    C1284_NAUTOFD |
			    C1284_NINIT |
			    C1284_NSELECTIN);
  return (port->ctr ^ C1284_INVERTED) & rm;
}

static void
write_control (struct parport_internal *port, unsigned char reg)
{
  const unsigned char wm = (C1284_NSTROBE |
			    C1284_NAUTOFD |
			    C1284_NINIT |
			    C1284_NSELECTIN);
  if (reg & 0x20)
    {
      /* Note: data direction not supported by LPT driver */
      printf ("error: setting data dir is invalid in this mode!\n");
    }

  raw_frob_control (port, wm, (unsigned char)(reg & wm));
}

static void
frob_control (struct parport_internal *port,
	      unsigned char mask,
	      unsigned char val)
{
  const unsigned char wm = (C1284_NSTROBE |
			    C1284_NAUTOFD |
			    C1284_NINIT |
			    C1284_NSELECTIN);
  if (mask & 0x20)
    {
      /* Note: data direction not supported by LPT driver */
      printf ("error: setting data dir is invalid in this mode!\n");
    }

  mask &= wm;
  val &= wm;
  raw_frob_control (port, mask, val);
}

static int
wait_status (struct parport_internal *port,
	     unsigned char mask, unsigned char val,
	     struct timeval *timeout)
{
  /* Simple-minded polling.  TODO: Use David Paschal's method for this. */
#if !(defined __MINGW32__ || defined _MSC_VER)
  struct timeval deadline, now;
  gettimeofday (&deadline, NULL);
  deadline.tv_sec += timeout->tv_sec;
  deadline.tv_usec += timeout->tv_usec;
  deadline.tv_sec += deadline.tv_usec / 1000000;
  deadline.tv_usec %= 1000000;
#else
  struct timeb tb;
  int deadline, now;
  ftime (&tb);
  deadline = tb.time * 1000 + tb.millitm +
             timeout->tv_sec * 1000 + timeout->tv_usec / 1000;
#endif

  do
    {
      if ((debug_display_status ((unsigned char)(read_status (port))) & mask) == val)
	return E1284_OK;

      delay (IO_POLL_DELAY);
#if !(defined __MINGW32__ || defined _MSC_VER)
      gettimeofday (&now, NULL);
    }
  while (now.tv_sec < deadline.tv_sec ||
    (now.tv_sec == deadline.tv_sec &&
	  now.tv_usec < deadline.tv_usec));
#else
      ftime (&tb);
      now = tb.time * 1000 + tb.millitm;
    }
  while (now < deadline);
#endif

  return E1284_TIMEDOUT;
}

const struct parport_access_methods lpt_access_methods =
{
  init,
  cleanup,

  NULL, /* claim */
  NULL, /* release */

  NULL, /* raw_inb */
  NULL, /* raw_outb */

  NULL, /* get_irq_fd */
  NULL, /* clear_irq */

  NULL, /* read_data */
  write_data,
  default_wait_data,
  NULL, /* data_dir */

  read_status,
  wait_status,

  read_control,
  write_control,
  frob_control,

  default_do_nack_handshake,
  default_negotiate,
  default_terminate,
  default_ecp_fwd_to_rev,
  default_ecp_rev_to_fwd,
  default_nibble_read,
  default_compat_write,
  default_byte_read,
  default_epp_read_data,
  default_epp_write_data,
  default_epp_read_addr,
  default_epp_write_addr,
  default_ecp_read_data,
  default_ecp_write_data,
  default_ecp_read_addr,
  default_ecp_write_addr,
  default_set_timeout
};
#else

/* Null struct to keep the compiler happy */
const struct parport_access_methods lpt_access_methods =
{
  NULL,
  NULL,

  NULL,
  NULL,

  NULL, /* inb */
  NULL, /* outb */

  NULL,
  NULL,

  NULL,
  NULL,
  NULL,
  NULL,

  NULL,
  NULL,

  NULL,
  NULL,
  NULL,

  NULL,

  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL 
};

#endif /* HAVE_CYGWIN_NT */

/*
 * Local Variables:
 * eval: (c-set-style "gnu")
 * End:
 */