/* $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; }