/*      $NetBSD: isv.c,v 1.7 2014/07/25 08:10:37 dholland Exp $ */

/*-
* Copyright (c) 2008 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by David Young.
*
* 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 NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``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 FOUNDATION OR CONTRIBUTORS
* 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 <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: isv.c,v 1.7 2014/07/25 08:10:37 dholland Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/device.h>
#include <sys/conf.h>

#include <uvm/uvm_extern.h>

#include <sys/bus.h>

#include <dev/isa/isareg.h>
#include <dev/isa/isavar.h>

#include <dev/isa/isvio.h>

#define ISV_CONTROL     0x0             /* control: write-only */
#define ISV_CONTROL_MODE_MASK           __BIT(0)
#define ISV_CONTROL_MODE_CAPTURE        __SHIFTIN(0, ISV_CONTROL_MODE_MASK)
#define ISV_CONTROL_MODE_READ           __SHIFTIN(1, ISV_CONTROL_MODE_MASK)
#define ISV_CONTROL_COUNTER_MASK        __BIT(1)
#define ISV_CONTROL_COUNTER_RESET       __SHIFTIN(1, ISV_CONTROL_COUNTER_MASK)
#define ISV_CONTROL_COUNTER_AUTOINC     __SHIFTIN(0, ISV_CONTROL_COUNTER_MASK)

#define ISV_DATA        ISV_CONTROL     /* data: read-only */

#define ISV_STATUS      0x2             /* status: read-only */
#define ISV_STATUS_VIDEO_MASK           __BIT(15)
#define ISV_STATUS_VIDEO_RETRACE        __SHIFTIN(0, ISV_STATUS_VIDEO_MASK)
#define ISV_STATUS_VIDEO_WRITE          __SHIFTIN(1, ISV_STATUS_VIDEO_MASK)

struct isv_regs {
       bus_space_tag_t         ir_bt;
       bus_space_handle_t      ir_bh;
};

enum isv_state {
         ISV_S_CAPTURE0 = 0
       , ISV_S_CAPTURE1 = 1
       , ISV_S_CAPTURE2 = 2
       , ISV_S_RETRACE = 3
};

struct isv_softc {
       struct isv_regs sc_ir;
       device_t        sc_dev;
       uint16_t        *sc_frame;
       int             sc_speed;
};

extern struct cfdriver isv_cd;

static dev_type_ioctl(isv_ioctl);
static dev_type_open(isv_open);
static dev_type_mmap(isv_mmap);

static int      isv_capture(struct isv_softc *);
static int      isv_match(device_t, cfdata_t, void *);
static void     isv_attach(device_t, device_t, void *);
static int      isv_detach(device_t, int);
static uint16_t isv_read(struct isv_regs *, bus_size_t);
static void     isv_write(struct isv_regs *, bus_size_t, uint16_t);
static bool     isv_retrace(struct isv_regs *);
static int      isv_retrace_wait(struct isv_regs *, int *,
   const struct timeval *);
static int      isv_capture_wait(struct isv_regs *, int *,
   const struct timeval *);
static bool     isv_delta(int *, bool);
static int      isv_probe(struct isv_regs *);

CFATTACH_DECL_NEW(isv_isa, sizeof(struct isv_softc),
   isv_match, isv_attach, isv_detach, NULL);

const struct cdevsw isv_cdevsw = {
       .d_open = isv_open,
       .d_close = nullclose,
       .d_read = noread,
       .d_write = nowrite,
       .d_ioctl = isv_ioctl,
       .d_stop = nostop,
       .d_tty = notty,
       .d_poll = nopoll,
       .d_mmap = isv_mmap,
       .d_kqfilter = nokqfilter,
       .d_discard = nodiscard,
       .d_flag = D_OTHER
};

static uint16_t
isv_read(struct isv_regs *ir, bus_size_t reg)
{
       return bus_space_read_2(ir->ir_bt, ir->ir_bh, reg);
}

static void
isv_write(struct isv_regs *ir, bus_size_t reg, uint16_t val)
{
       bus_space_write_2(ir->ir_bt, ir->ir_bh, reg, val);
}

static bool
isv_retrace(struct isv_regs *ir)
{
       uint16_t video;

       video = isv_read(ir, ISV_STATUS) & ISV_STATUS_VIDEO_MASK;
       return video == ISV_STATUS_VIDEO_RETRACE;
}

#define state_and_input(__state, __retrace)     \
       (((__state) << 1) | ((__retrace) ? 1 : 0))

static bool
isv_delta(int *state, bool retrace)
{
       bool transition = false;

       switch (state_and_input(*state, retrace)) {
       case state_and_input(ISV_S_CAPTURE0, false):
       case state_and_input(ISV_S_RETRACE, true):
               break;
       case state_and_input(ISV_S_CAPTURE2, true):
               transition = true;
               /*FALLTHROUGH*/
       case state_and_input(ISV_S_CAPTURE1, true):
       case state_and_input(ISV_S_CAPTURE0, true):
               (*state)++;
               break;
       case state_and_input(ISV_S_RETRACE, false):
               transition = true;
               /*FALLTHROUGH*/
       case state_and_input(ISV_S_CAPTURE2, false):
       case state_and_input(ISV_S_CAPTURE1, false):
               *state = ISV_S_CAPTURE0;
               break;
       }
       return transition;
}

static int
isv_probe(struct isv_regs *ir)
{
       int state, transitions;
       struct timeval end, now,
           wait = {.tv_sec = 0, .tv_usec = 1000000 * 4 / 30};

       aprint_debug("%s: resetting\n", __func__);
       isv_write(ir, ISV_CONTROL,
           ISV_CONTROL_MODE_CAPTURE|ISV_CONTROL_COUNTER_AUTOINC);

       aprint_debug("%s: waiting\n", __func__);

       microtime(&now);
       timeradd(&now, &wait, &end);

       state = transitions = 0;

       do {
               if (isv_delta(&state, isv_retrace(ir)))
                       transitions++;

               if (state == ISV_S_CAPTURE0 || state == ISV_S_RETRACE)
                       microtime(&now);
       } while (timercmp(&now, &end, <));

       aprint_debug("%s: %d transitions\n", __func__, transitions);

       return transitions >= 4 && transitions <= 10;
}

static int
isv_match(device_t parent, cfdata_t match, void *aux)
{
       struct isv_regs ir;
       struct isa_attach_args *ia = aux;
       int rv;

       /* Must supply an address */
       if (ia->ia_nio < 1 || ia->ia_io[0].ir_addr == ISA_UNKNOWN_PORT)
               return 0;

       ir.ir_bt = ia->ia_iot;

       if (bus_space_map(ir.ir_bt, ia->ia_io[0].ir_addr, 8, 0, &ir.ir_bh))
               return 0;

       rv = isv_probe(&ir);

       bus_space_unmap(ir.ir_bt, ir.ir_bh, 8);

       if (rv) {
               ia->ia_nio = 1;
               ia->ia_io[0].ir_size = 8;

               ia->ia_niomem = 0;
               ia->ia_nirq = 0;
               ia->ia_ndrq = 0;
       }

       return rv;
}


static void
isv_attach(device_t parent, device_t self, void *aux)
{
       struct isv_softc *sc = device_private(self);
       struct isv_regs *ir = &sc->sc_ir;
       struct isa_attach_args *ia = aux;

       ir->ir_bt = ia->ia_iot;

       if (bus_space_map(ir->ir_bt, ia->ia_io[0].ir_addr, 8, 0, &ir->ir_bh)) {
               aprint_error(": can't map i/o space\n");
               return;
       }

       /* Bus-independent attachment */
       sc->sc_dev = self;

       aprint_normal(": IDEC Supervision/16\n");

       /* TBD */
}

int
isv_open(dev_t dev, int flag, int devtype, lwp_t *l)
{
       vaddr_t va;
       struct isv_softc *sc = device_lookup_private(&isv_cd, minor(dev));

       if (sc == NULL)
               return ENXIO;

       if (sc->sc_frame != NULL)
               return 0;

       if ((va = uvm_km_alloc(kernel_map, ISV_WIDTH * ISV_LINES, PAGE_SIZE,
           UVM_KMF_WIRED|UVM_KMF_ZERO|UVM_KMF_CANFAIL|UVM_KMF_WAITVA)) == 0)
               return ENOMEM;

       sc->sc_frame = (uint16_t *)(void *)va;
       return 0;
}

/* wait for retrace */
static int
isv_retrace_wait(struct isv_regs *ir, int *state, const struct timeval *end)
{
       struct timeval now;

       for (;;) {
               if (!isv_delta(state, isv_retrace(ir))) {
                       microtime(&now);
                       continue;
               }
               if (*state == ISV_S_RETRACE)
                       break;
               if (*state != ISV_S_CAPTURE0)
                       continue;

               microtime(&now);
               if (timercmp(&now, end, >=))
                       return EIO;
       }
       return 0;
}

/* wait for capture mode */
static int
isv_capture_wait(struct isv_regs *ir, int *state, const struct timeval *end)
{
       struct timeval now;

       for (;;) {
               if (!isv_delta(state, isv_retrace(ir))) {
                       microtime(&now);
                       continue;
               }
               if (*state != ISV_S_RETRACE)
                       break;

               microtime(&now);
               if (timercmp(&now, end, >=))
                       return EIO;
       }
       return 0;
}


static int
isv_capture(struct isv_softc *sc)
{
       int speed;
       int rc, state = ISV_S_CAPTURE0;
       struct timeval diff, end, start, stop;
       static const struct timeval wait = {.tv_sec = 0, .tv_usec = 200000};
       struct isv_regs *ir = &sc->sc_ir;

       if (sc->sc_frame == NULL)
               return EAGAIN;

       microtime(&start);

       timeradd(&start, &wait, &end);

       speed = sc->sc_speed;
       sc->sc_speed = 0;

       if (speed < 1 && (rc = isv_retrace_wait(ir, &state, &end)) != 0)
               return rc;

       if (speed < 2 && (rc = isv_capture_wait(ir, &state, &end)) != 0)
               return rc;

       if ((rc = isv_retrace_wait(ir, &state, &end)) != 0)
               return rc;

       microtime(&stop);

       timersub(&stop, &start, &diff);

       aprint_debug_dev(sc->sc_dev, "%ssync in %" PRId64 ".%06d seconds\n",
           (speed < 1) ? "" : ((speed < 2) ? "faster " : "fastest "),
           diff.tv_sec, diff.tv_usec);

       microtime(&start);

       /* enter read mode, then toggle counter mode,
        * autoinc -> reset -> autoinc, so that we start reading
        * at the top of the frame.
        */
       isv_write(ir, ISV_CONTROL,
           ISV_CONTROL_MODE_READ|ISV_CONTROL_COUNTER_AUTOINC);
       isv_write(ir, ISV_CONTROL,
           ISV_CONTROL_MODE_READ|ISV_CONTROL_COUNTER_RESET);
       isv_write(ir, ISV_CONTROL,
           ISV_CONTROL_MODE_READ|ISV_CONTROL_COUNTER_AUTOINC);
       /* read one dummy word to prime the state machine on the
        * image capture board
        */
       isv_read(ir, ISV_DATA);
       bus_space_read_multi_stream_2(ir->ir_bt, ir->ir_bh, ISV_DATA,
           sc->sc_frame, ISV_WIDTH * ISV_LINES / 2);

       /* restore to initial conditions */
       isv_write(ir, ISV_CONTROL,
           ISV_CONTROL_MODE_CAPTURE|ISV_CONTROL_COUNTER_AUTOINC);

       microtime(&stop);

       timersub(&stop, &start, &diff);

       aprint_debug_dev(sc->sc_dev, "read in %" PRId64 ".%06d seconds\n",
               diff.tv_sec, diff.tv_usec);

       state = 0;

       if (isv_retrace_wait(ir, &state, &end) != 0)
               return 0;
       sc->sc_speed++;

       if (isv_capture_wait(ir, &state, &end) != 0)
               return 0;
       sc->sc_speed++;

       return 0;
}

int
isv_ioctl(dev_t dev, u_long cmd, void *data, int flag, lwp_t *l)
{
       struct isv_cmd ic;
       struct isv_softc *sc = device_lookup_private(&isv_cd, minor(dev));

       if (cmd != ISV_CMD)
               return ENOTTY;

       memcpy(&ic, data, sizeof(ic));

       if (ic.c_cmd != ISV_CMD_READ)
               return EINVAL;

       ic.c_frameno = 0;

       return isv_capture(sc);
}

paddr_t
isv_mmap(dev_t dev, off_t offset, int prot)
{
       struct isv_softc *sc = device_lookup_private(&isv_cd, minor(dev));
       paddr_t pa;

       if ((prot & ~(VM_PROT_READ)) != 0)
               return -1;

       if (sc->sc_frame == NULL)
               return -1;

       if (offset >= ISV_WIDTH * ISV_LINES)
               return -1;

       if (!pmap_extract(pmap_kernel(), (vaddr_t)&sc->sc_frame[offset/2], &pa))
               return -1;

       return atop(pa);
}

static int
isv_detach(device_t self, int flags)
{
       struct isv_softc *sc = device_private(self);
       struct isv_regs *ir = &sc->sc_ir;

       if (sc->sc_frame != NULL) {
               uvm_km_free(kernel_map, (vaddr_t)sc->sc_frame,
                   ISV_WIDTH * ISV_LINES, UVM_KMF_WIRED);
       }
       bus_space_unmap(ir->ir_bt, ir->ir_bh, 8);
       return 0;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.