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