1/* $NetBSD: isv.c,v 1.6 2014/03/23 02:50:51 christos Exp $ */ 2 3/*- 4 * Copyright (c) 2008 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by David Young. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32#include <sys/cdefs.h> 33__KERNEL_RCSID(0, "$NetBSD: isv.c,v 1.6 2014/03/23 02:50:51 christos Exp $"); 34 35#include <sys/param.h> 36#include <sys/systm.h> 37#include <sys/kernel.h> 38#include <sys/device.h> 39#include <sys/conf.h> 40 41#include <uvm/uvm_extern.h> 42 43#include <sys/bus.h> 44 45#include <dev/isa/isareg.h> 46#include <dev/isa/isavar.h> 47 48#include <dev/isa/isvio.h> 49 50#define ISV_CONTROL 0x0 /* control: write-only */ 51#define ISV_CONTROL_MODE_MASK __BIT(0) 52#define ISV_CONTROL_MODE_CAPTURE __SHIFTIN(0, ISV_CONTROL_MODE_MASK) 53#define ISV_CONTROL_MODE_READ __SHIFTIN(1, ISV_CONTROL_MODE_MASK) 54#define ISV_CONTROL_COUNTER_MASK __BIT(1) 55#define ISV_CONTROL_COUNTER_RESET __SHIFTIN(1, ISV_CONTROL_COUNTER_MASK) 56#define ISV_CONTROL_COUNTER_AUTOINC __SHIFTIN(0, ISV_CONTROL_COUNTER_MASK) 57 58#define ISV_DATA ISV_CONTROL /* data: read-only */ 59 60#define ISV_STATUS 0x2 /* status: read-only */ 61#define ISV_STATUS_VIDEO_MASK __BIT(15) 62#define ISV_STATUS_VIDEO_RETRACE __SHIFTIN(0, ISV_STATUS_VIDEO_MASK) 63#define ISV_STATUS_VIDEO_WRITE __SHIFTIN(1, ISV_STATUS_VIDEO_MASK) 64 65struct isv_regs { 66 bus_space_tag_t ir_bt; 67 bus_space_handle_t ir_bh; 68}; 69 70enum isv_state { 71 ISV_S_CAPTURE0 = 0 72 , ISV_S_CAPTURE1 = 1 73 , ISV_S_CAPTURE2 = 2 74 , ISV_S_RETRACE = 3 75}; 76 77struct isv_softc { 78 struct isv_regs sc_ir; 79 device_t sc_dev; 80 uint16_t *sc_frame; 81 int sc_speed; 82}; 83 84extern struct cfdriver isv_cd; 85 86static dev_type_ioctl(isv_ioctl); 87static dev_type_open(isv_open); 88static dev_type_mmap(isv_mmap); 89 90static int isv_capture(struct isv_softc *); 91static int isv_match(device_t, cfdata_t, void *); 92static void isv_attach(device_t, device_t, void *); 93static int isv_detach(device_t, int); 94static uint16_t isv_read(struct isv_regs *, bus_size_t); 95static void isv_write(struct isv_regs *, bus_size_t, uint16_t); 96static bool isv_retrace(struct isv_regs *); 97static int isv_retrace_wait(struct isv_regs *, int *, 98 const struct timeval *); 99static int isv_capture_wait(struct isv_regs *, int *, 100 const struct timeval *); 101static bool isv_delta(int *, bool); 102static int isv_probe(struct isv_regs *); 103 104CFATTACH_DECL_NEW(isv_isa, sizeof(struct isv_softc), 105 isv_match, isv_attach, isv_detach, NULL); 106 107const struct cdevsw isv_cdevsw = { 108 .d_open = isv_open, 109 .d_close = nullclose, 110 .d_read = noread, 111 .d_write = nowrite, 112 .d_ioctl = isv_ioctl, 113 .d_stop = nostop, 114 .d_tty = notty, 115 .d_poll = nopoll, 116 .d_mmap = isv_mmap, 117 .d_kqfilter = nokqfilter, 118 .d_discard = nodiscard, 119 .d_flag = D_OTHER 120}; 121 122static uint16_t 123isv_read(struct isv_regs *ir, bus_size_t reg) 124{ 125 return bus_space_read_2(ir->ir_bt, ir->ir_bh, reg); 126} 127 128static void 129isv_write(struct isv_regs *ir, bus_size_t reg, uint16_t val) 130{ 131 bus_space_write_2(ir->ir_bt, ir->ir_bh, reg, val); 132} 133 134static bool 135isv_retrace(struct isv_regs *ir) 136{ 137 uint16_t video; 138 139 video = isv_read(ir, ISV_STATUS) & ISV_STATUS_VIDEO_MASK; 140 return video == ISV_STATUS_VIDEO_RETRACE; 141} 142 143#define state_and_input(__state, __retrace) \ 144 (((__state) << 1) | ((__retrace) ? 1 : 0)) 145 146static bool 147isv_delta(int *state, bool retrace) 148{ 149 bool transition = false; 150 151 switch (state_and_input(*state, retrace)) { 152 case state_and_input(ISV_S_CAPTURE0, false): 153 case state_and_input(ISV_S_RETRACE, true): 154 break; 155 case state_and_input(ISV_S_CAPTURE2, true): 156 transition = true; 157 /*FALLTHROUGH*/ 158 case state_and_input(ISV_S_CAPTURE1, true): 159 case state_and_input(ISV_S_CAPTURE0, true): 160 (*state)++; 161 break; 162 case state_and_input(ISV_S_RETRACE, false): 163 transition = true; 164 /*FALLTHROUGH*/ 165 case state_and_input(ISV_S_CAPTURE2, false): 166 case state_and_input(ISV_S_CAPTURE1, false): 167 *state = ISV_S_CAPTURE0; 168 break; 169 } 170 return transition; 171} 172 173static int 174isv_probe(struct isv_regs *ir) 175{ 176 int state, transitions; 177 struct timeval end, now, 178 wait = {.tv_sec = 0, .tv_usec = 1000000 * 4 / 30}; 179 180 aprint_debug("%s: resetting\n", __func__); 181 isv_write(ir, ISV_CONTROL, 182 ISV_CONTROL_MODE_CAPTURE|ISV_CONTROL_COUNTER_AUTOINC); 183 184 aprint_debug("%s: waiting\n", __func__); 185 186 microtime(&now); 187 timeradd(&now, &wait, &end); 188 189 state = transitions = 0; 190 191 do { 192 if (isv_delta(&state, isv_retrace(ir))) 193 transitions++; 194 195 if (state == ISV_S_CAPTURE0 || state == ISV_S_RETRACE) 196 microtime(&now); 197 } while (timercmp(&now, &end, <)); 198 199 aprint_debug("%s: %d transitions\n", __func__, transitions); 200 201 return transitions >= 4 && transitions <= 10; 202} 203 204static int 205isv_match(device_t parent, cfdata_t match, void *aux) 206{ 207 struct isv_regs ir; 208 struct isa_attach_args *ia = aux; 209 int rv; 210 211 /* Must supply an address */ 212 if (ia->ia_nio < 1 || ia->ia_io[0].ir_addr == ISA_UNKNOWN_PORT) 213 return 0; 214 215 ir.ir_bt = ia->ia_iot; 216 217 if (bus_space_map(ir.ir_bt, ia->ia_io[0].ir_addr, 8, 0, &ir.ir_bh)) 218 return 0; 219 220 rv = isv_probe(&ir); 221 222 bus_space_unmap(ir.ir_bt, ir.ir_bh, 8); 223 224 if (rv) { 225 ia->ia_nio = 1; 226 ia->ia_io[0].ir_size = 8; 227 228 ia->ia_niomem = 0; 229 ia->ia_nirq = 0; 230 ia->ia_ndrq = 0; 231 } 232 233 return rv; 234} 235 236 237static void 238isv_attach(device_t parent, device_t self, void *aux) 239{ 240 struct isv_softc *sc = device_private(self); 241 struct isv_regs *ir = &sc->sc_ir; 242 struct isa_attach_args *ia = aux; 243 244 ir->ir_bt = ia->ia_iot; 245 246 if (bus_space_map(ir->ir_bt, ia->ia_io[0].ir_addr, 8, 0, &ir->ir_bh)) { 247 aprint_error(": can't map i/o space\n"); 248 return; 249 } 250 251 /* Bus-independent attachment */ 252 sc->sc_dev = self; 253 254 aprint_normal(": IDEC Supervision/16\n"); 255 256 /* TBD */ 257} 258 259int 260isv_open(dev_t dev, int flag, int devtype, lwp_t *l) 261{ 262 vaddr_t va; 263 struct isv_softc *sc = device_lookup_private(&isv_cd, minor(dev)); 264 265 if (sc == NULL) 266 return ENXIO; 267 268 if (sc->sc_frame != NULL) 269 return 0; 270 271 if ((va = uvm_km_alloc(kernel_map, ISV_WIDTH * ISV_LINES, PAGE_SIZE, 272 UVM_KMF_WIRED|UVM_KMF_ZERO|UVM_KMF_CANFAIL|UVM_KMF_WAITVA)) == 0) 273 return ENOMEM; 274 275 sc->sc_frame = (uint16_t *)(void *)va; 276 return 0; 277} 278 279/* wait for retrace */ 280static int 281isv_retrace_wait(struct isv_regs *ir, int *state, const struct timeval *end) 282{ 283 struct timeval now; 284 285 for (;;) { 286 if (!isv_delta(state, isv_retrace(ir))) { 287 microtime(&now); 288 continue; 289 } 290 if (*state == ISV_S_RETRACE) 291 break; 292 if (*state != ISV_S_CAPTURE0) 293 continue; 294 295 microtime(&now); 296 if (timercmp(&now, end, >=)) 297 return EIO; 298 } 299 return 0; 300} 301 302/* wait for capture mode */ 303static int 304isv_capture_wait(struct isv_regs *ir, int *state, const struct timeval *end) 305{ 306 struct timeval now; 307 308 for (;;) { 309 if (!isv_delta(state, isv_retrace(ir))) { 310 microtime(&now); 311 continue; 312 } 313 if (*state != ISV_S_RETRACE) 314 break; 315 316 microtime(&now); 317 if (timercmp(&now, end, >=)) 318 return EIO; 319 } 320 return 0; 321} 322 323 324static int 325isv_capture(struct isv_softc *sc) 326{ 327 int speed; 328 int rc, state = ISV_S_CAPTURE0; 329 struct timeval diff, end, start, stop; 330 static const struct timeval wait = {.tv_sec = 0, .tv_usec = 200000}; 331 struct isv_regs *ir = &sc->sc_ir; 332 333 if (sc->sc_frame == NULL) 334 return EAGAIN; 335 336 microtime(&start); 337 338 timeradd(&start, &wait, &end); 339 340 speed = sc->sc_speed; 341 sc->sc_speed = 0; 342 343 if (speed < 1 && (rc = isv_retrace_wait(ir, &state, &end)) != 0) 344 return rc; 345 346 if (speed < 2 && (rc = isv_capture_wait(ir, &state, &end)) != 0) 347 return rc; 348 349 if ((rc = isv_retrace_wait(ir, &state, &end)) != 0) 350 return rc; 351 352 microtime(&stop); 353 354 timersub(&stop, &start, &diff); 355 356 aprint_debug_dev(sc->sc_dev, "%ssync in %" PRId64 ".%06d seconds\n", 357 (speed < 1) ? "" : ((speed < 2) ? "faster " : "fastest "), 358 diff.tv_sec, diff.tv_usec); 359 360 microtime(&start); 361 362 /* enter read mode, then toggle counter mode, 363 * autoinc -> reset -> autoinc, so that we start reading 364 * at the top of the frame. 365 */ 366 isv_write(ir, ISV_CONTROL, 367 ISV_CONTROL_MODE_READ|ISV_CONTROL_COUNTER_AUTOINC); 368 isv_write(ir, ISV_CONTROL, 369 ISV_CONTROL_MODE_READ|ISV_CONTROL_COUNTER_RESET); 370 isv_write(ir, ISV_CONTROL, 371 ISV_CONTROL_MODE_READ|ISV_CONTROL_COUNTER_AUTOINC); 372 /* read one dummy word to prime the state machine on the 373 * image capture board 374 */ 375 isv_read(ir, ISV_DATA); 376 bus_space_read_multi_stream_2(ir->ir_bt, ir->ir_bh, ISV_DATA, 377 sc->sc_frame, ISV_WIDTH * ISV_LINES / 2); 378 379 /* restore to initial conditions */ 380 isv_write(ir, ISV_CONTROL, 381 ISV_CONTROL_MODE_CAPTURE|ISV_CONTROL_COUNTER_AUTOINC); 382 383 microtime(&stop); 384 385 timersub(&stop, &start, &diff); 386 387 aprint_debug_dev(sc->sc_dev, "read in %" PRId64 ".%06d seconds\n", 388 diff.tv_sec, diff.tv_usec); 389 390 state = 0; 391 392 if (isv_retrace_wait(ir, &state, &end) != 0) 393 return 0; 394 sc->sc_speed++; 395 396 if (isv_capture_wait(ir, &state, &end) != 0) 397 return 0; 398 sc->sc_speed++; 399 400 return 0; 401} 402 403int 404isv_ioctl(dev_t dev, u_long cmd, void *data, int flag, lwp_t *l) 405{ 406 struct isv_cmd ic; 407 struct isv_softc *sc = device_lookup_private(&isv_cd, minor(dev)); 408 409 if (cmd != ISV_CMD) 410 return ENOTTY; 411 412 memcpy(&ic, data, sizeof(ic)); 413 414 if (ic.c_cmd != ISV_CMD_READ) 415 return EINVAL; 416 417 ic.c_frameno = 0; 418 419 return isv_capture(sc); 420} 421 422paddr_t 423isv_mmap(dev_t dev, off_t offset, int prot) 424{ 425 struct isv_softc *sc = device_lookup_private(&isv_cd, minor(dev)); 426 paddr_t pa; 427 428 if ((prot & ~(VM_PROT_READ)) != 0) 429 return -1; 430 431 if (sc->sc_frame == NULL) 432 return -1; 433 434 if (offset >= ISV_WIDTH * ISV_LINES) 435 return -1; 436 437 if (!pmap_extract(pmap_kernel(), (vaddr_t)&sc->sc_frame[offset/2], &pa)) 438 return -1; 439 440 return atop(pa); 441} 442 443static int 444isv_detach(device_t self, int flags) 445{ 446 struct isv_softc *sc = device_private(self); 447 struct isv_regs *ir = &sc->sc_ir; 448 449 if (sc->sc_frame != NULL) { 450 uvm_km_free(kernel_map, (vaddr_t)sc->sc_frame, 451 ISV_WIDTH * ISV_LINES, UVM_KMF_WIRED); 452 } 453 bus_space_unmap(ir->ir_bt, ir->ir_bh, 8); 454 return 0; 455} 456