456 lines
11 KiB
C
456 lines
11 KiB
C
/* $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;
|
|
}
|