PageRenderTime 52ms CodeModel.GetById 17ms app.highlight 30ms RepoModel.GetById 0ms app.codeStats 1ms

/drivers/media/video/bw-qcam.c

https://bitbucket.org/ndreys/linux-sunxi
C | 1094 lines | 755 code | 162 blank | 177 comment | 117 complexity | 22edf3d83e39310ade9d1e539cf82a79 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
   1/*
   2 *    QuickCam Driver For Video4Linux.
   3 *
   4 *	Video4Linux conversion work by Alan Cox.
   5 *	Parport compatibility by Phil Blundell.
   6 *	Busy loop avoidance by Mark Cooke.
   7 *
   8 *    Module parameters:
   9 *
  10 *	maxpoll=<1 - 5000>
  11 *
  12 *	  When polling the QuickCam for a response, busy-wait for a
  13 *	  maximum of this many loops. The default of 250 gives little
  14 *	  impact on interactive response.
  15 *
  16 *	  NOTE: If this parameter is set too high, the processor
  17 *		will busy wait until this loop times out, and then
  18 *		slowly poll for a further 5 seconds before failing
  19 *		the transaction. You have been warned.
  20 *
  21 *	yieldlines=<1 - 250>
  22 *
  23 *	  When acquiring a frame from the camera, the data gathering
  24 *	  loop will yield back to the scheduler after completing
  25 *	  this many lines. The default of 4 provides a trade-off
  26 *	  between increased frame acquisition time and impact on
  27 *	  interactive response.
  28 */
  29
  30/* qcam-lib.c -- Library for programming with the Connectix QuickCam.
  31 * See the included documentation for usage instructions and details
  32 * of the protocol involved. */
  33
  34
  35/* Version 0.5, August 4, 1996 */
  36/* Version 0.7, August 27, 1996 */
  37/* Version 0.9, November 17, 1996 */
  38
  39
  40/******************************************************************
  41
  42Copyright (C) 1996 by Scott Laird
  43
  44Permission is hereby granted, free of charge, to any person obtaining
  45a copy of this software and associated documentation files (the
  46"Software"), to deal in the Software without restriction, including
  47without limitation the rights to use, copy, modify, merge, publish,
  48distribute, sublicense, and/or sell copies of the Software, and to
  49permit persons to whom the Software is furnished to do so, subject to
  50the following conditions:
  51
  52The above copyright notice and this permission notice shall be
  53included in all copies or substantial portions of the Software.
  54
  55THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  56EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  57MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  58IN NO EVENT SHALL SCOTT LAIRD BE LIABLE FOR ANY CLAIM, DAMAGES OR
  59OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  60ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  61OTHER DEALINGS IN THE SOFTWARE.
  62
  63******************************************************************/
  64
  65#include <linux/module.h>
  66#include <linux/delay.h>
  67#include <linux/errno.h>
  68#include <linux/fs.h>
  69#include <linux/kernel.h>
  70#include <linux/slab.h>
  71#include <linux/mm.h>
  72#include <linux/parport.h>
  73#include <linux/sched.h>
  74#include <linux/version.h>
  75#include <linux/videodev2.h>
  76#include <linux/mutex.h>
  77#include <asm/uaccess.h>
  78#include <media/v4l2-common.h>
  79#include <media/v4l2-ioctl.h>
  80#include <media/v4l2-device.h>
  81
  82/* One from column A... */
  83#define QC_NOTSET 0
  84#define QC_UNIDIR 1
  85#define QC_BIDIR  2
  86#define QC_SERIAL 3
  87
  88/* ... and one from column B */
  89#define QC_ANY          0x00
  90#define QC_FORCE_UNIDIR 0x10
  91#define QC_FORCE_BIDIR  0x20
  92#define QC_FORCE_SERIAL 0x30
  93/* in the port_mode member */
  94
  95#define QC_MODE_MASK    0x07
  96#define QC_FORCE_MASK   0x70
  97
  98#define MAX_HEIGHT 243
  99#define MAX_WIDTH 336
 100
 101/* Bit fields for status flags */
 102#define QC_PARAM_CHANGE	0x01 /* Camera status change has occurred */
 103
 104struct qcam {
 105	struct v4l2_device v4l2_dev;
 106	struct video_device vdev;
 107	struct pardevice *pdev;
 108	struct parport *pport;
 109	struct mutex lock;
 110	int width, height;
 111	int bpp;
 112	int mode;
 113	int contrast, brightness, whitebal;
 114	int port_mode;
 115	int transfer_scale;
 116	int top, left;
 117	int status;
 118	unsigned int saved_bits;
 119	unsigned long in_use;
 120};
 121
 122static unsigned int maxpoll = 250;   /* Maximum busy-loop count for qcam I/O */
 123static unsigned int yieldlines = 4;  /* Yield after this many during capture */
 124static int video_nr = -1;
 125static unsigned int force_init;		/* Whether to probe aggressively */
 126
 127module_param(maxpoll, int, 0);
 128module_param(yieldlines, int, 0);
 129module_param(video_nr, int, 0);
 130
 131/* Set force_init=1 to avoid detection by polling status register and
 132 * immediately attempt to initialize qcam */
 133module_param(force_init, int, 0);
 134
 135#define MAX_CAMS 4
 136static struct qcam *qcams[MAX_CAMS];
 137static unsigned int num_cams;
 138
 139static inline int read_lpstatus(struct qcam *q)
 140{
 141	return parport_read_status(q->pport);
 142}
 143
 144static inline int read_lpdata(struct qcam *q)
 145{
 146	return parport_read_data(q->pport);
 147}
 148
 149static inline void write_lpdata(struct qcam *q, int d)
 150{
 151	parport_write_data(q->pport, d);
 152}
 153
 154static void write_lpcontrol(struct qcam *q, int d)
 155{
 156	if (d & 0x20) {
 157		/* Set bidirectional mode to reverse (data in) */
 158		parport_data_reverse(q->pport);
 159	} else {
 160		/* Set bidirectional mode to forward (data out) */
 161		parport_data_forward(q->pport);
 162	}
 163
 164	/* Now issue the regular port command, but strip out the
 165	 * direction flag */
 166	d &= ~0x20;
 167	parport_write_control(q->pport, d);
 168}
 169
 170
 171/* qc_waithand busy-waits for a handshake signal from the QuickCam.
 172 * Almost all communication with the camera requires handshaking. */
 173
 174static int qc_waithand(struct qcam *q, int val)
 175{
 176	int status;
 177	int runs = 0;
 178
 179	if (val) {
 180		while (!((status = read_lpstatus(q)) & 8)) {
 181			/* 1000 is enough spins on the I/O for all normal
 182			   cases, at that point we start to poll slowly
 183			   until the camera wakes up. However, we are
 184			   busy blocked until the camera responds, so
 185			   setting it lower is much better for interactive
 186			   response. */
 187
 188			if (runs++ > maxpoll)
 189				msleep_interruptible(5);
 190			if (runs > (maxpoll + 1000)) /* 5 seconds */
 191				return -1;
 192		}
 193	} else {
 194		while (((status = read_lpstatus(q)) & 8)) {
 195			/* 1000 is enough spins on the I/O for all normal
 196			   cases, at that point we start to poll slowly
 197			   until the camera wakes up. However, we are
 198			   busy blocked until the camera responds, so
 199			   setting it lower is much better for interactive
 200			   response. */
 201
 202			if (runs++ > maxpoll)
 203				msleep_interruptible(5);
 204			if (runs++ > (maxpoll + 1000)) /* 5 seconds */
 205				return -1;
 206		}
 207	}
 208
 209	return status;
 210}
 211
 212/* Waithand2 is used when the qcam is in bidirectional mode, and the
 213 * handshaking signal is CamRdy2 (bit 0 of data reg) instead of CamRdy1
 214 * (bit 3 of status register).  It also returns the last value read,
 215 * since this data is useful. */
 216
 217static unsigned int qc_waithand2(struct qcam *q, int val)
 218{
 219	unsigned int status;
 220	int runs = 0;
 221
 222	do {
 223		status = read_lpdata(q);
 224		/* 1000 is enough spins on the I/O for all normal
 225		   cases, at that point we start to poll slowly
 226		   until the camera wakes up. However, we are
 227		   busy blocked until the camera responds, so
 228		   setting it lower is much better for interactive
 229		   response. */
 230
 231		if (runs++ > maxpoll)
 232			msleep_interruptible(5);
 233		if (runs++ > (maxpoll + 1000)) /* 5 seconds */
 234			return 0;
 235	} while ((status & 1) != val);
 236
 237	return status;
 238}
 239
 240/* qc_command is probably a bit of a misnomer -- it's used to send
 241 * bytes *to* the camera.  Generally, these bytes are either commands
 242 * or arguments to commands, so the name fits, but it still bugs me a
 243 * bit.  See the documentation for a list of commands. */
 244
 245static int qc_command(struct qcam *q, int command)
 246{
 247	int n1, n2;
 248	int cmd;
 249
 250	write_lpdata(q, command);
 251	write_lpcontrol(q, 6);
 252
 253	n1 = qc_waithand(q, 1);
 254
 255	write_lpcontrol(q, 0xe);
 256	n2 = qc_waithand(q, 0);
 257
 258	cmd = (n1 & 0xf0) | ((n2 & 0xf0) >> 4);
 259	return cmd;
 260}
 261
 262static int qc_readparam(struct qcam *q)
 263{
 264	int n1, n2;
 265	int cmd;
 266
 267	write_lpcontrol(q, 6);
 268	n1 = qc_waithand(q, 1);
 269
 270	write_lpcontrol(q, 0xe);
 271	n2 = qc_waithand(q, 0);
 272
 273	cmd = (n1 & 0xf0) | ((n2 & 0xf0) >> 4);
 274	return cmd;
 275}
 276
 277
 278/* Try to detect a QuickCam.  It appears to flash the upper 4 bits of
 279   the status register at 5-10 Hz.  This is only used in the autoprobe
 280   code.  Be aware that this isn't the way Connectix detects the
 281   camera (they send a reset and try to handshake), but this should be
 282   almost completely safe, while their method screws up my printer if
 283   I plug it in before the camera. */
 284
 285static int qc_detect(struct qcam *q)
 286{
 287	int reg, lastreg;
 288	int count = 0;
 289	int i;
 290
 291	if (force_init)
 292		return 1;
 293
 294	lastreg = reg = read_lpstatus(q) & 0xf0;
 295
 296	for (i = 0; i < 500; i++) {
 297		reg = read_lpstatus(q) & 0xf0;
 298		if (reg != lastreg)
 299			count++;
 300		lastreg = reg;
 301		mdelay(2);
 302	}
 303
 304
 305#if 0
 306	/* Force camera detection during testing. Sometimes the camera
 307	   won't be flashing these bits. Possibly unloading the module
 308	   in the middle of a grab? Or some timeout condition?
 309	   I've seen this parameter as low as 19 on my 450Mhz box - mpc */
 310	printk(KERN_DEBUG "Debugging: QCam detection counter <30-200 counts as detected>: %d\n", count);
 311	return 1;
 312#endif
 313
 314	/* Be (even more) liberal in what you accept...  */
 315
 316	if (count > 20 && count < 400) {
 317		return 1;	/* found */
 318	} else {
 319		printk(KERN_ERR "No Quickcam found on port %s\n",
 320				q->pport->name);
 321		printk(KERN_DEBUG "Quickcam detection counter: %u\n", count);
 322		return 0;	/* not found */
 323	}
 324}
 325
 326/* Decide which scan mode to use.  There's no real requirement that
 327 * the scanmode match the resolution in q->height and q-> width -- the
 328 * camera takes the picture at the resolution specified in the
 329 * "scanmode" and then returns the image at the resolution specified
 330 * with the resolution commands.  If the scan is bigger than the
 331 * requested resolution, the upper-left hand corner of the scan is
 332 * returned.  If the scan is smaller, then the rest of the image
 333 * returned contains garbage. */
 334
 335static int qc_setscanmode(struct qcam *q)
 336{
 337	int old_mode = q->mode;
 338
 339	switch (q->transfer_scale) {
 340	case 1:
 341		q->mode = 0;
 342		break;
 343	case 2:
 344		q->mode = 4;
 345		break;
 346	case 4:
 347		q->mode = 8;
 348		break;
 349	}
 350
 351	switch (q->bpp) {
 352	case 4:
 353		break;
 354	case 6:
 355		q->mode += 2;
 356		break;
 357	}
 358
 359	switch (q->port_mode & QC_MODE_MASK) {
 360	case QC_BIDIR:
 361		q->mode += 1;
 362		break;
 363	case QC_NOTSET:
 364	case QC_UNIDIR:
 365		break;
 366	}
 367
 368	if (q->mode != old_mode)
 369		q->status |= QC_PARAM_CHANGE;
 370
 371	return 0;
 372}
 373
 374
 375/* Reset the QuickCam.  This uses the same sequence the Windows
 376 * QuickPic program uses.  Someone with a bi-directional port should
 377 * check that bi-directional mode is detected right, and then
 378 * implement bi-directional mode in qc_readbyte(). */
 379
 380static void qc_reset(struct qcam *q)
 381{
 382	switch (q->port_mode & QC_FORCE_MASK) {
 383	case QC_FORCE_UNIDIR:
 384		q->port_mode = (q->port_mode & ~QC_MODE_MASK) | QC_UNIDIR;
 385		break;
 386
 387	case QC_FORCE_BIDIR:
 388		q->port_mode = (q->port_mode & ~QC_MODE_MASK) | QC_BIDIR;
 389		break;
 390
 391	case QC_ANY:
 392		write_lpcontrol(q, 0x20);
 393		write_lpdata(q, 0x75);
 394
 395		if (read_lpdata(q) != 0x75)
 396			q->port_mode = (q->port_mode & ~QC_MODE_MASK) | QC_BIDIR;
 397		else
 398			q->port_mode = (q->port_mode & ~QC_MODE_MASK) | QC_UNIDIR;
 399		break;
 400	}
 401
 402	write_lpcontrol(q, 0xb);
 403	udelay(250);
 404	write_lpcontrol(q, 0xe);
 405	qc_setscanmode(q);		/* in case port_mode changed */
 406}
 407
 408
 409
 410/* Reset the QuickCam and program for brightness, contrast,
 411 * white-balance, and resolution. */
 412
 413static void qc_set(struct qcam *q)
 414{
 415	int val;
 416	int val2;
 417
 418	qc_reset(q);
 419
 420	/* Set the brightness.  Yes, this is repetitive, but it works.
 421	 * Shorter versions seem to fail subtly.  Feel free to try :-). */
 422	/* I think the problem was in qc_command, not here -- bls */
 423
 424	qc_command(q, 0xb);
 425	qc_command(q, q->brightness);
 426
 427	val = q->height / q->transfer_scale;
 428	qc_command(q, 0x11);
 429	qc_command(q, val);
 430	if ((q->port_mode & QC_MODE_MASK) == QC_UNIDIR && q->bpp == 6) {
 431		/* The normal "transfers per line" calculation doesn't seem to work
 432		   as expected here (and yet it works fine in qc_scan).  No idea
 433		   why this case is the odd man out.  Fortunately, Laird's original
 434		   working version gives me a good way to guess at working values.
 435		   -- bls */
 436		val = q->width;
 437		val2 = q->transfer_scale * 4;
 438	} else {
 439		val = q->width * q->bpp;
 440		val2 = (((q->port_mode & QC_MODE_MASK) == QC_BIDIR) ? 24 : 8) *
 441			q->transfer_scale;
 442	}
 443	val = DIV_ROUND_UP(val, val2);
 444	qc_command(q, 0x13);
 445	qc_command(q, val);
 446
 447	/* Setting top and left -- bls */
 448	qc_command(q, 0xd);
 449	qc_command(q, q->top);
 450	qc_command(q, 0xf);
 451	qc_command(q, q->left / 2);
 452
 453	qc_command(q, 0x19);
 454	qc_command(q, q->contrast);
 455	qc_command(q, 0x1f);
 456	qc_command(q, q->whitebal);
 457
 458	/* Clear flag that we must update the grabbing parameters on the camera
 459	   before we grab the next frame */
 460	q->status &= (~QC_PARAM_CHANGE);
 461}
 462
 463/* Qc_readbytes reads some bytes from the QC and puts them in
 464   the supplied buffer.  It returns the number of bytes read,
 465   or -1 on error. */
 466
 467static inline int qc_readbytes(struct qcam *q, char buffer[])
 468{
 469	int ret = 1;
 470	unsigned int hi, lo;
 471	unsigned int hi2, lo2;
 472	static int state;
 473
 474	if (buffer == NULL) {
 475		state = 0;
 476		return 0;
 477	}
 478
 479	switch (q->port_mode & QC_MODE_MASK) {
 480	case QC_BIDIR:		/* Bi-directional Port */
 481		write_lpcontrol(q, 0x26);
 482		lo = (qc_waithand2(q, 1) >> 1);
 483		hi = (read_lpstatus(q) >> 3) & 0x1f;
 484		write_lpcontrol(q, 0x2e);
 485		lo2 = (qc_waithand2(q, 0) >> 1);
 486		hi2 = (read_lpstatus(q) >> 3) & 0x1f;
 487		switch (q->bpp) {
 488		case 4:
 489			buffer[0] = lo & 0xf;
 490			buffer[1] = ((lo & 0x70) >> 4) | ((hi & 1) << 3);
 491			buffer[2] = (hi & 0x1e) >> 1;
 492			buffer[3] = lo2 & 0xf;
 493			buffer[4] = ((lo2 & 0x70) >> 4) | ((hi2 & 1) << 3);
 494			buffer[5] = (hi2 & 0x1e) >> 1;
 495			ret = 6;
 496			break;
 497		case 6:
 498			buffer[0] = lo & 0x3f;
 499			buffer[1] = ((lo & 0x40) >> 6) | (hi << 1);
 500			buffer[2] = lo2 & 0x3f;
 501			buffer[3] = ((lo2 & 0x40) >> 6) | (hi2 << 1);
 502			ret = 4;
 503			break;
 504		}
 505		break;
 506
 507	case QC_UNIDIR:	/* Unidirectional Port */
 508		write_lpcontrol(q, 6);
 509		lo = (qc_waithand(q, 1) & 0xf0) >> 4;
 510		write_lpcontrol(q, 0xe);
 511		hi = (qc_waithand(q, 0) & 0xf0) >> 4;
 512
 513		switch (q->bpp) {
 514		case 4:
 515			buffer[0] = lo;
 516			buffer[1] = hi;
 517			ret = 2;
 518			break;
 519		case 6:
 520			switch (state) {
 521			case 0:
 522				buffer[0] = (lo << 2) | ((hi & 0xc) >> 2);
 523				q->saved_bits = (hi & 3) << 4;
 524				state = 1;
 525				ret = 1;
 526				break;
 527			case 1:
 528				buffer[0] = lo | q->saved_bits;
 529				q->saved_bits = hi << 2;
 530				state = 2;
 531				ret = 1;
 532				break;
 533			case 2:
 534				buffer[0] = ((lo & 0xc) >> 2) | q->saved_bits;
 535				buffer[1] = ((lo & 3) << 4) | hi;
 536				state = 0;
 537				ret = 2;
 538				break;
 539			}
 540			break;
 541		}
 542		break;
 543	}
 544	return ret;
 545}
 546
 547/* requests a scan from the camera.  It sends the correct instructions
 548 * to the camera and then reads back the correct number of bytes.  In
 549 * previous versions of this routine the return structure contained
 550 * the raw output from the camera, and there was a 'qc_convertscan'
 551 * function that converted that to a useful format.  In version 0.3 I
 552 * rolled qc_convertscan into qc_scan and now I only return the
 553 * converted scan.  The format is just an one-dimensional array of
 554 * characters, one for each pixel, with 0=black up to n=white, where
 555 * n=2^(bit depth)-1.  Ask me for more details if you don't understand
 556 * this. */
 557
 558static long qc_capture(struct qcam *q, char __user *buf, unsigned long len)
 559{
 560	int i, j, k, yield;
 561	int bytes;
 562	int linestotrans, transperline;
 563	int divisor;
 564	int pixels_per_line;
 565	int pixels_read = 0;
 566	int got = 0;
 567	char buffer[6];
 568	int  shift = 8 - q->bpp;
 569	char invert;
 570
 571	if (q->mode == -1)
 572		return -ENXIO;
 573
 574	qc_command(q, 0x7);
 575	qc_command(q, q->mode);
 576
 577	if ((q->port_mode & QC_MODE_MASK) == QC_BIDIR) {
 578		write_lpcontrol(q, 0x2e);	/* turn port around */
 579		write_lpcontrol(q, 0x26);
 580		qc_waithand(q, 1);
 581		write_lpcontrol(q, 0x2e);
 582		qc_waithand(q, 0);
 583	}
 584
 585	/* strange -- should be 15:63 below, but 4bpp is odd */
 586	invert = (q->bpp == 4) ? 16 : 63;
 587
 588	linestotrans = q->height / q->transfer_scale;
 589	pixels_per_line = q->width / q->transfer_scale;
 590	transperline = q->width * q->bpp;
 591	divisor = (((q->port_mode & QC_MODE_MASK) == QC_BIDIR) ? 24 : 8) *
 592		q->transfer_scale;
 593	transperline = DIV_ROUND_UP(transperline, divisor);
 594
 595	for (i = 0, yield = yieldlines; i < linestotrans; i++) {
 596		for (pixels_read = j = 0; j < transperline; j++) {
 597			bytes = qc_readbytes(q, buffer);
 598			for (k = 0; k < bytes && (pixels_read + k) < pixels_per_line; k++) {
 599				int o;
 600				if (buffer[k] == 0 && invert == 16) {
 601					/* 4bpp is odd (again) -- inverter is 16, not 15, but output
 602					   must be 0-15 -- bls */
 603					buffer[k] = 16;
 604				}
 605				o = i * pixels_per_line + pixels_read + k;
 606				if (o < len) {
 607					got++;
 608					put_user((invert - buffer[k]) << shift, buf + o);
 609				}
 610			}
 611			pixels_read += bytes;
 612		}
 613		qc_readbytes(q, NULL);	/* reset state machine */
 614
 615		/* Grabbing an entire frame from the quickcam is a lengthy
 616		   process. We don't (usually) want to busy-block the
 617		   processor for the entire frame. yieldlines is a module
 618		   parameter. If we yield every line, the minimum frame
 619		   time will be 240 / 200 = 1.2 seconds. The compile-time
 620		   default is to yield every 4 lines. */
 621		if (i >= yield) {
 622			msleep_interruptible(5);
 623			yield = i + yieldlines;
 624		}
 625	}
 626
 627	if ((q->port_mode & QC_MODE_MASK) == QC_BIDIR) {
 628		write_lpcontrol(q, 2);
 629		write_lpcontrol(q, 6);
 630		udelay(3);
 631		write_lpcontrol(q, 0xe);
 632	}
 633	if (got < len)
 634		return got;
 635	return len;
 636}
 637
 638/*
 639 *	Video4linux interfacing
 640 */
 641
 642static int qcam_querycap(struct file *file, void  *priv,
 643					struct v4l2_capability *vcap)
 644{
 645	struct qcam *qcam = video_drvdata(file);
 646
 647	strlcpy(vcap->driver, qcam->v4l2_dev.name, sizeof(vcap->driver));
 648	strlcpy(vcap->card, "B&W Quickcam", sizeof(vcap->card));
 649	strlcpy(vcap->bus_info, "parport", sizeof(vcap->bus_info));
 650	vcap->version = KERNEL_VERSION(0, 0, 2);
 651	vcap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE;
 652	return 0;
 653}
 654
 655static int qcam_enum_input(struct file *file, void *fh, struct v4l2_input *vin)
 656{
 657	if (vin->index > 0)
 658		return -EINVAL;
 659	strlcpy(vin->name, "Camera", sizeof(vin->name));
 660	vin->type = V4L2_INPUT_TYPE_CAMERA;
 661	vin->audioset = 0;
 662	vin->tuner = 0;
 663	vin->std = 0;
 664	vin->status = 0;
 665	return 0;
 666}
 667
 668static int qcam_g_input(struct file *file, void *fh, unsigned int *inp)
 669{
 670	*inp = 0;
 671	return 0;
 672}
 673
 674static int qcam_s_input(struct file *file, void *fh, unsigned int inp)
 675{
 676	return (inp > 0) ? -EINVAL : 0;
 677}
 678
 679static int qcam_queryctrl(struct file *file, void *priv,
 680					struct v4l2_queryctrl *qc)
 681{
 682	switch (qc->id) {
 683	case V4L2_CID_BRIGHTNESS:
 684		return v4l2_ctrl_query_fill(qc, 0, 255, 1, 180);
 685	case V4L2_CID_CONTRAST:
 686		return v4l2_ctrl_query_fill(qc, 0, 255, 1, 192);
 687	case V4L2_CID_GAMMA:
 688		return v4l2_ctrl_query_fill(qc, 0, 255, 1, 105);
 689	}
 690	return -EINVAL;
 691}
 692
 693static int qcam_g_ctrl(struct file *file, void *priv,
 694					struct v4l2_control *ctrl)
 695{
 696	struct qcam *qcam = video_drvdata(file);
 697	int ret = 0;
 698
 699	switch (ctrl->id) {
 700	case V4L2_CID_BRIGHTNESS:
 701		ctrl->value = qcam->brightness;
 702		break;
 703	case V4L2_CID_CONTRAST:
 704		ctrl->value = qcam->contrast;
 705		break;
 706	case V4L2_CID_GAMMA:
 707		ctrl->value = qcam->whitebal;
 708		break;
 709	default:
 710		ret = -EINVAL;
 711		break;
 712	}
 713	return ret;
 714}
 715
 716static int qcam_s_ctrl(struct file *file, void *priv,
 717					struct v4l2_control *ctrl)
 718{
 719	struct qcam *qcam = video_drvdata(file);
 720	int ret = 0;
 721
 722	mutex_lock(&qcam->lock);
 723	switch (ctrl->id) {
 724	case V4L2_CID_BRIGHTNESS:
 725		qcam->brightness = ctrl->value;
 726		break;
 727	case V4L2_CID_CONTRAST:
 728		qcam->contrast = ctrl->value;
 729		break;
 730	case V4L2_CID_GAMMA:
 731		qcam->whitebal = ctrl->value;
 732		break;
 733	default:
 734		ret = -EINVAL;
 735		break;
 736	}
 737	if (ret == 0) {
 738		qc_setscanmode(qcam);
 739		qcam->status |= QC_PARAM_CHANGE;
 740	}
 741	mutex_unlock(&qcam->lock);
 742	return ret;
 743}
 744
 745static int qcam_g_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 746{
 747	struct qcam *qcam = video_drvdata(file);
 748	struct v4l2_pix_format *pix = &fmt->fmt.pix;
 749
 750	pix->width = qcam->width / qcam->transfer_scale;
 751	pix->height = qcam->height / qcam->transfer_scale;
 752	pix->pixelformat = (qcam->bpp == 4) ? V4L2_PIX_FMT_Y4 : V4L2_PIX_FMT_Y6;
 753	pix->field = V4L2_FIELD_NONE;
 754	pix->bytesperline = qcam->width;
 755	pix->sizeimage = qcam->width * qcam->height;
 756	/* Just a guess */
 757	pix->colorspace = V4L2_COLORSPACE_SRGB;
 758	return 0;
 759}
 760
 761static int qcam_try_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 762{
 763	struct v4l2_pix_format *pix = &fmt->fmt.pix;
 764
 765	if (pix->height <= 60 || pix->width <= 80) {
 766		pix->height = 60;
 767		pix->width = 80;
 768	} else if (pix->height <= 120 || pix->width <= 160) {
 769		pix->height = 120;
 770		pix->width = 160;
 771	} else {
 772		pix->height = 240;
 773		pix->width = 320;
 774	}
 775	if (pix->pixelformat != V4L2_PIX_FMT_Y4 &&
 776	    pix->pixelformat != V4L2_PIX_FMT_Y6)
 777		pix->pixelformat = V4L2_PIX_FMT_Y4;
 778	pix->field = V4L2_FIELD_NONE;
 779	pix->bytesperline = pix->width;
 780	pix->sizeimage = pix->width * pix->height;
 781	/* Just a guess */
 782	pix->colorspace = V4L2_COLORSPACE_SRGB;
 783	return 0;
 784}
 785
 786static int qcam_s_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 787{
 788	struct qcam *qcam = video_drvdata(file);
 789	struct v4l2_pix_format *pix = &fmt->fmt.pix;
 790	int ret = qcam_try_fmt_vid_cap(file, fh, fmt);
 791
 792	if (ret)
 793		return ret;
 794	qcam->width = 320;
 795	qcam->height = 240;
 796	if (pix->height == 60)
 797		qcam->transfer_scale = 4;
 798	else if (pix->height == 120)
 799		qcam->transfer_scale = 2;
 800	else
 801		qcam->transfer_scale = 1;
 802	if (pix->pixelformat == V4L2_PIX_FMT_Y6)
 803		qcam->bpp = 6;
 804	else
 805		qcam->bpp = 4;
 806
 807	mutex_lock(&qcam->lock);
 808	qc_setscanmode(qcam);
 809	/* We must update the camera before we grab. We could
 810	   just have changed the grab size */
 811	qcam->status |= QC_PARAM_CHANGE;
 812	mutex_unlock(&qcam->lock);
 813	return 0;
 814}
 815
 816static int qcam_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
 817{
 818	static struct v4l2_fmtdesc formats[] = {
 819		{ 0, 0, 0,
 820		  "4-Bit Monochrome", V4L2_PIX_FMT_Y4,
 821		  { 0, 0, 0, 0 }
 822		},
 823		{ 0, 0, 0,
 824		  "6-Bit Monochrome", V4L2_PIX_FMT_Y6,
 825		  { 0, 0, 0, 0 }
 826		},
 827	};
 828	enum v4l2_buf_type type = fmt->type;
 829
 830	if (fmt->index > 1)
 831		return -EINVAL;
 832
 833	*fmt = formats[fmt->index];
 834	fmt->type = type;
 835	return 0;
 836}
 837
 838static ssize_t qcam_read(struct file *file, char __user *buf,
 839		size_t count, loff_t *ppos)
 840{
 841	struct qcam *qcam = video_drvdata(file);
 842	int len;
 843	parport_claim_or_block(qcam->pdev);
 844
 845	mutex_lock(&qcam->lock);
 846
 847	qc_reset(qcam);
 848
 849	/* Update the camera parameters if we need to */
 850	if (qcam->status & QC_PARAM_CHANGE)
 851		qc_set(qcam);
 852
 853	len = qc_capture(qcam, buf, count);
 854
 855	mutex_unlock(&qcam->lock);
 856
 857	parport_release(qcam->pdev);
 858	return len;
 859}
 860
 861static const struct v4l2_file_operations qcam_fops = {
 862	.owner		= THIS_MODULE,
 863	.unlocked_ioctl = video_ioctl2,
 864	.read		= qcam_read,
 865};
 866
 867static const struct v4l2_ioctl_ops qcam_ioctl_ops = {
 868	.vidioc_querycap    		    = qcam_querycap,
 869	.vidioc_g_input      		    = qcam_g_input,
 870	.vidioc_s_input      		    = qcam_s_input,
 871	.vidioc_enum_input   		    = qcam_enum_input,
 872	.vidioc_queryctrl 		    = qcam_queryctrl,
 873	.vidioc_g_ctrl  		    = qcam_g_ctrl,
 874	.vidioc_s_ctrl 			    = qcam_s_ctrl,
 875	.vidioc_enum_fmt_vid_cap 	    = qcam_enum_fmt_vid_cap,
 876	.vidioc_g_fmt_vid_cap 		    = qcam_g_fmt_vid_cap,
 877	.vidioc_s_fmt_vid_cap  		    = qcam_s_fmt_vid_cap,
 878	.vidioc_try_fmt_vid_cap  	    = qcam_try_fmt_vid_cap,
 879};
 880
 881/* Initialize the QuickCam driver control structure.  This is where
 882 * defaults are set for people who don't have a config file.*/
 883
 884static struct qcam *qcam_init(struct parport *port)
 885{
 886	struct qcam *qcam;
 887	struct v4l2_device *v4l2_dev;
 888
 889	qcam = kzalloc(sizeof(struct qcam), GFP_KERNEL);
 890	if (qcam == NULL)
 891		return NULL;
 892
 893	v4l2_dev = &qcam->v4l2_dev;
 894	strlcpy(v4l2_dev->name, "bw-qcam", sizeof(v4l2_dev->name));
 895
 896	if (v4l2_device_register(NULL, v4l2_dev) < 0) {
 897		v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
 898		return NULL;
 899	}
 900
 901	qcam->pport = port;
 902	qcam->pdev = parport_register_device(port, "bw-qcam", NULL, NULL,
 903			NULL, 0, NULL);
 904	if (qcam->pdev == NULL) {
 905		v4l2_err(v4l2_dev, "couldn't register for %s.\n", port->name);
 906		kfree(qcam);
 907		return NULL;
 908	}
 909
 910	strlcpy(qcam->vdev.name, "Connectix QuickCam", sizeof(qcam->vdev.name));
 911	qcam->vdev.v4l2_dev = v4l2_dev;
 912	qcam->vdev.fops = &qcam_fops;
 913	qcam->vdev.ioctl_ops = &qcam_ioctl_ops;
 914	qcam->vdev.release = video_device_release_empty;
 915	video_set_drvdata(&qcam->vdev, qcam);
 916
 917	mutex_init(&qcam->lock);
 918
 919	qcam->port_mode = (QC_ANY | QC_NOTSET);
 920	qcam->width = 320;
 921	qcam->height = 240;
 922	qcam->bpp = 4;
 923	qcam->transfer_scale = 2;
 924	qcam->contrast = 192;
 925	qcam->brightness = 180;
 926	qcam->whitebal = 105;
 927	qcam->top = 1;
 928	qcam->left = 14;
 929	qcam->mode = -1;
 930	qcam->status = QC_PARAM_CHANGE;
 931	return qcam;
 932}
 933
 934static int qc_calibrate(struct qcam *q)
 935{
 936	/*
 937	 *	Bugfix by Hanno Mueller hmueller@kabel.de, Mai 21 96
 938	 *	The white balance is an individual value for each
 939	 *	quickcam.
 940	 */
 941
 942	int value;
 943	int count = 0;
 944
 945	qc_command(q, 27);	/* AutoAdjustOffset */
 946	qc_command(q, 0);	/* Dummy Parameter, ignored by the camera */
 947
 948	/* GetOffset (33) will read 255 until autocalibration */
 949	/* is finished. After that, a value of 1-254 will be */
 950	/* returned. */
 951
 952	do {
 953		qc_command(q, 33);
 954		value = qc_readparam(q);
 955		mdelay(1);
 956		schedule();
 957		count++;
 958	} while (value == 0xff && count < 2048);
 959
 960	q->whitebal = value;
 961	return value;
 962}
 963
 964static int init_bwqcam(struct parport *port)
 965{
 966	struct qcam *qcam;
 967
 968	if (num_cams == MAX_CAMS) {
 969		printk(KERN_ERR "Too many Quickcams (max %d)\n", MAX_CAMS);
 970		return -ENOSPC;
 971	}
 972
 973	qcam = qcam_init(port);
 974	if (qcam == NULL)
 975		return -ENODEV;
 976
 977	parport_claim_or_block(qcam->pdev);
 978
 979	qc_reset(qcam);
 980
 981	if (qc_detect(qcam) == 0) {
 982		parport_release(qcam->pdev);
 983		parport_unregister_device(qcam->pdev);
 984		kfree(qcam);
 985		return -ENODEV;
 986	}
 987	qc_calibrate(qcam);
 988
 989	parport_release(qcam->pdev);
 990
 991	v4l2_info(&qcam->v4l2_dev, "Connectix Quickcam on %s\n", qcam->pport->name);
 992
 993	if (video_register_device(&qcam->vdev, VFL_TYPE_GRABBER, video_nr) < 0) {
 994		parport_unregister_device(qcam->pdev);
 995		kfree(qcam);
 996		return -ENODEV;
 997	}
 998
 999	qcams[num_cams++] = qcam;
1000
1001	return 0;
1002}
1003
1004static void close_bwqcam(struct qcam *qcam)
1005{
1006	video_unregister_device(&qcam->vdev);
1007	parport_unregister_device(qcam->pdev);
1008	kfree(qcam);
1009}
1010
1011/* The parport parameter controls which parports will be scanned.
1012 * Scanning all parports causes some printers to print a garbage page.
1013 *       -- March 14, 1999  Billy Donahue <billy@escape.com> */
1014#ifdef MODULE
1015static char *parport[MAX_CAMS] = { NULL, };
1016module_param_array(parport, charp, NULL, 0);
1017#endif
1018
1019static int accept_bwqcam(struct parport *port)
1020{
1021#ifdef MODULE
1022	int n;
1023
1024	if (parport[0] && strncmp(parport[0], "auto", 4) != 0) {
1025		/* user gave parport parameters */
1026		for (n = 0; n < MAX_CAMS && parport[n]; n++) {
1027			char *ep;
1028			unsigned long r;
1029			r = simple_strtoul(parport[n], &ep, 0);
1030			if (ep == parport[n]) {
1031				printk(KERN_ERR
1032					"bw-qcam: bad port specifier \"%s\"\n",
1033					parport[n]);
1034				continue;
1035			}
1036			if (r == port->number)
1037				return 1;
1038		}
1039		return 0;
1040	}
1041#endif
1042	return 1;
1043}
1044
1045static void bwqcam_attach(struct parport *port)
1046{
1047	if (accept_bwqcam(port))
1048		init_bwqcam(port);
1049}
1050
1051static void bwqcam_detach(struct parport *port)
1052{
1053	int i;
1054	for (i = 0; i < num_cams; i++) {
1055		struct qcam *qcam = qcams[i];
1056		if (qcam && qcam->pdev->port == port) {
1057			qcams[i] = NULL;
1058			close_bwqcam(qcam);
1059		}
1060	}
1061}
1062
1063static struct parport_driver bwqcam_driver = {
1064	.name	= "bw-qcam",
1065	.attach	= bwqcam_attach,
1066	.detach	= bwqcam_detach,
1067};
1068
1069static void __exit exit_bw_qcams(void)
1070{
1071	parport_unregister_driver(&bwqcam_driver);
1072}
1073
1074static int __init init_bw_qcams(void)
1075{
1076#ifdef MODULE
1077	/* Do some sanity checks on the module parameters. */
1078	if (maxpoll > 5000) {
1079		printk(KERN_INFO "Connectix Quickcam max-poll was above 5000. Using 5000.\n");
1080		maxpoll = 5000;
1081	}
1082
1083	if (yieldlines < 1) {
1084		printk(KERN_INFO "Connectix Quickcam yieldlines was less than 1. Using 1.\n");
1085		yieldlines = 1;
1086	}
1087#endif
1088	return parport_register_driver(&bwqcam_driver);
1089}
1090
1091module_init(init_bw_qcams);
1092module_exit(exit_bw_qcams);
1093
1094MODULE_LICENSE("GPL");