meye.c

linux-2.6.15.6

		break;
	}

	case MEYEIOC_G_PARAMS: {
		struct meye_params *p = arg;
		*p = meye.params;
		break;
	}

	case MEYEIOC_S_PARAMS: {
		struct meye_params *jp = arg;
		if (jp->subsample > 1)
			return -EINVAL;
		if (jp->quality > 10)
			return -EINVAL;
		if (jp->sharpness > 63 || jp->agc > 63 || jp->picture > 63)
			return -EINVAL;
		if (jp->framerate > 31)
			return -EINVAL;
		down(&meye.lock);
		if (meye.params.subsample != jp->subsample ||
		    meye.params.quality != jp->quality)
			mchip_hic_stop();	/* need restart */
		meye.params = *jp;
		sonypi_camera_command(SONYPI_COMMAND_SETCAMERASHARPNESS,
				      meye.params.sharpness);
		sonypi_camera_command(SONYPI_COMMAND_SETCAMERAAGC,
				      meye.params.agc);
		sonypi_camera_command(SONYPI_COMMAND_SETCAMERAPICTURE,
				      meye.params.picture);
		up(&meye.lock);
		break;
	}

	case MEYEIOC_QBUF_CAPT: {
		int *nb = arg;

		if (!meye.grab_fbuffer)
			return -EINVAL;
		if (*nb >= gbuffers)
			return -EINVAL;
		if (*nb < 0) {
			/* stop capture */
			mchip_hic_stop();
			return 0;
		}
		if (meye.grab_buffer[*nb].state != MEYE_BUF_UNUSED)
			return -EBUSY;
		down(&meye.lock);
		if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
			mchip_cont_compression_start();
		meye.grab_buffer[*nb].state = MEYE_BUF_USING;
		kfifo_put(meye.grabq, (unsigned char *)nb, sizeof(int));
		up(&meye.lock);
		break;
	}

	case MEYEIOC_SYNC: {
		int *i = arg;
		int unused;

		if (*i < 0 || *i >= gbuffers)
			return -EINVAL;

		down(&meye.lock);
		switch (meye.grab_buffer[*i].state) {

		case MEYE_BUF_UNUSED:
			up(&meye.lock);
			return -EINVAL;
		case MEYE_BUF_USING:
			if (file->f_flags & O_NONBLOCK) {
				up(&meye.lock);
				return -EAGAIN;
			}
			if (wait_event_interruptible(meye.proc_list,
						     (meye.grab_buffer[*i].state != MEYE_BUF_USING))) {
				up(&meye.lock);
				return -EINTR;
			}
			/* fall through */
		case MEYE_BUF_DONE:
			meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
			kfifo_get(meye.doneq, (unsigned char *)&unused, sizeof(int));
		}
		*i = meye.grab_buffer[*i].size;
		up(&meye.lock);
		break;
	}

	case MEYEIOC_STILLCAPT: {

		if (!meye.grab_fbuffer)
			return -EINVAL;
		if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
			return -EBUSY;
		down(&meye.lock);
		meye.grab_buffer[0].state = MEYE_BUF_USING;
		mchip_take_picture();
		mchip_get_picture(
			meye.grab_fbuffer,
			mchip_hsize() * mchip_vsize() * 2);
		meye.grab_buffer[0].state = MEYE_BUF_DONE;
		up(&meye.lock);
		break;
	}

	case MEYEIOC_STILLJCAPT: {
		int *len = arg;

		if (!meye.grab_fbuffer)
			return -EINVAL;
		if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
			return -EBUSY;
		down(&meye.lock);
		meye.grab_buffer[0].state = MEYE_BUF_USING;
		*len = -1;
		while (*len == -1) {
			mchip_take_picture();
			*len = mchip_compress_frame(meye.grab_fbuffer, gbufsize);
		}
		meye.grab_buffer[0].state = MEYE_BUF_DONE;
		up(&meye.lock);
		break;
	}

	case VIDIOC_QUERYCAP: {
		struct v4l2_capability *cap = arg;

		if (forcev4l1)
			return -EINVAL;

		memset(cap, 0, sizeof(*cap));
		strcpy(cap->driver, "meye");
		strcpy(cap->card, "meye");
		sprintf(cap->bus_info, "PCI:%s", pci_name(meye.mchip_dev));
		cap->version = (MEYE_DRIVER_MAJORVERSION << 8) +
			       MEYE_DRIVER_MINORVERSION;
		cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
				    V4L2_CAP_STREAMING;
		break;
	}

	case VIDIOC_ENUMINPUT: {
		struct v4l2_input *i = arg;

		if (i->index != 0)
			return -EINVAL;
		memset(i, 0, sizeof(*i));
		i->index = 0;
		strcpy(i->name, "Camera");
		i->type = V4L2_INPUT_TYPE_CAMERA;
		break;
	}

	case VIDIOC_G_INPUT: {
		int *i = arg;

		*i = 0;
		break;
	}

	case VIDIOC_S_INPUT: {
		int *i = arg;

		if (*i != 0)
			return -EINVAL;
		break;
	}

	case VIDIOC_QUERYCTRL: {
		struct v4l2_queryctrl *c = arg;

		switch (c->id) {

		case V4L2_CID_BRIGHTNESS:
			c->type = V4L2_CTRL_TYPE_INTEGER;
			strcpy(c->name, "Brightness");
			c->minimum = 0;
			c->maximum = 63;
			c->step = 1;
			c->default_value = 32;
			c->flags = 0;
			break;
		case V4L2_CID_HUE:
			c->type = V4L2_CTRL_TYPE_INTEGER;
			strcpy(c->name, "Hue");
			c->minimum = 0;
			c->maximum = 63;
			c->step = 1;
			c->default_value = 32;
			c->flags = 0;
			break;
		case V4L2_CID_CONTRAST:
			c->type = V4L2_CTRL_TYPE_INTEGER;
			strcpy(c->name, "Contrast");
			c->minimum = 0;
			c->maximum = 63;
			c->step = 1;
			c->default_value = 32;
			c->flags = 0;
			break;
		case V4L2_CID_SATURATION:
			c->type = V4L2_CTRL_TYPE_INTEGER;
			strcpy(c->name, "Saturation");
			c->minimum = 0;
			c->maximum = 63;
			c->step = 1;
			c->default_value = 32;
			c->flags = 0;
			break;
		case V4L2_CID_AGC:
			c->type = V4L2_CTRL_TYPE_INTEGER;
			strcpy(c->name, "Agc");
			c->minimum = 0;
			c->maximum = 63;
			c->step = 1;
			c->default_value = 48;
			c->flags = 0;
			break;
		case V4L2_CID_SHARPNESS:
			c->type = V4L2_CTRL_TYPE_INTEGER;
			strcpy(c->name, "Sharpness");
			c->minimum = 0;
			c->maximum = 63;
			c->step = 1;
			c->default_value = 32;
			c->flags = 0;
			break;
		case V4L2_CID_PICTURE:
			c->type = V4L2_CTRL_TYPE_INTEGER;
			strcpy(c->name, "Picture");
			c->minimum = 0;
			c->maximum = 63;
			c->step = 1;
			c->default_value = 0;
			c->flags = 0;
			break;
		case V4L2_CID_JPEGQUAL:
			c->type = V4L2_CTRL_TYPE_INTEGER;
			strcpy(c->name, "JPEG quality");
			c->minimum = 0;
			c->maximum = 10;
			c->step = 1;
			c->default_value = 8;
			c->flags = 0;
			break;
		case V4L2_CID_FRAMERATE:
			c->type = V4L2_CTRL_TYPE_INTEGER;
			strcpy(c->name, "Framerate");
			c->minimum = 0;
			c->maximum = 31;
			c->step = 1;
			c->default_value = 0;
			c->flags = 0;
			break;
		default:
			return -EINVAL;
		}
		break;
	}

	case VIDIOC_S_CTRL: {
		struct v4l2_control *c = arg;

		down(&meye.lock);
		switch (c->id) {
		case V4L2_CID_BRIGHTNESS:
			sonypi_camera_command(
				SONYPI_COMMAND_SETCAMERABRIGHTNESS, c->value);
			meye.picture.brightness = c->value << 10;
			break;
		case V4L2_CID_HUE:
			sonypi_camera_command(
				SONYPI_COMMAND_SETCAMERAHUE, c->value);
			meye.picture.hue = c->value << 10;
			break;
		case V4L2_CID_CONTRAST:
			sonypi_camera_command(
				SONYPI_COMMAND_SETCAMERACONTRAST, c->value);
			meye.picture.contrast = c->value << 10;
			break;
		case V4L2_CID_SATURATION:
			sonypi_camera_command(
				SONYPI_COMMAND_SETCAMERACOLOR, c->value);
			meye.picture.colour = c->value << 10;
			break;
		case V4L2_CID_AGC:
			sonypi_camera_command(
				SONYPI_COMMAND_SETCAMERAAGC, c->value);
			meye.params.agc = c->value;
			break;
		case V4L2_CID_SHARPNESS:
			sonypi_camera_command(
				SONYPI_COMMAND_SETCAMERASHARPNESS, c->value);
			meye.params.sharpness = c->value;
			break;
		case V4L2_CID_PICTURE:
			sonypi_camera_command(
				SONYPI_COMMAND_SETCAMERAPICTURE, c->value);
			meye.params.picture = c->value;
			break;
		case V4L2_CID_JPEGQUAL:
			meye.params.quality = c->value;
			break;
		case V4L2_CID_FRAMERATE:
			meye.params.framerate = c->value;
			break;
		default:
			up(&meye.lock);
			return -EINVAL;
		}
		up(&meye.lock);
		break;
	}

	case VIDIOC_G_CTRL: {
		struct v4l2_control *c = arg;

		down(&meye.lock);
		switch (c->id) {
		case V4L2_CID_BRIGHTNESS:
			c->value = meye.picture.brightness >> 10;
			break;
		case V4L2_CID_HUE:
			c->value = meye.picture.hue >> 10;
			break;
		case V4L2_CID_CONTRAST:
			c->value = meye.picture.contrast >> 10;
			break;
		case V4L2_CID_SATURATION:
			c->value = meye.picture.colour >> 10;
			break;
		case V4L2_CID_AGC:
			c->value = meye.params.agc;
			break;
		case V4L2_CID_SHARPNESS:
			c->value = meye.params.sharpness;
			break;
		case V4L2_CID_PICTURE:
			c->value = meye.params.picture;
			break;
		case V4L2_CID_JPEGQUAL:
			c->value = meye.params.quality;
			break;
		case V4L2_CID_FRAMERATE:
			c->value = meye.params.framerate;
			break;
		default:
			up(&meye.lock);
			return -EINVAL;
		}
		up(&meye.lock);
		break;
	}

	case VIDIOC_ENUM_FMT: {
		struct v4l2_fmtdesc *f = arg;

		if (f->index > 1)
			return -EINVAL;
		if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
			return -EINVAL;
		if (f->index == 0) {
			/* standard YUV 422 capture */
			memset(f, 0, sizeof(*f));
			f->index = 0;
			f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
			f->flags = 0;
			strcpy(f->description, "YUV422");
			f->pixelformat = V4L2_PIX_FMT_YUYV;
		} else {
			/* compressed MJPEG capture */
			memset(f, 0, sizeof(*f));
			f->index = 1;
			f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
			f->flags = V4L2_FMT_FLAG_COMPRESSED;
			strcpy(f->description, "MJPEG");
			f->pixelformat = V4L2_PIX_FMT_MJPEG;
		}
		break;
	}

	case VIDIOC_TRY_FMT: {
		struct v4l2_format *f = arg;

		if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
			return -EINVAL;
		if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
		    f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
			return -EINVAL;
		if (f->fmt.pix.field != V4L2_FIELD_ANY &&
		    f->fmt.pix.field != V4L2_FIELD_NONE)
			return -EINVAL;
		f->fmt.pix.field = V4L2_FIELD_NONE;
		if (f->fmt.pix.width <= 320) {
			f->fmt.pix.width = 320;
			f->fmt.pix.height = 240;
		} else {
			f->fmt.pix.width = 640;
			f->fmt.pix.height = 480;
		}
		f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
		f->fmt.pix.sizeimage = f->fmt.pix.height *
				       f->fmt.pix.bytesperline;
		f->fmt.pix.colorspace = 0;
		f->fmt.pix.priv = 0;
		break;
	}

	case VIDIOC_G_FMT: {
		struct v4l2_format *f = arg;

		if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
			return -EINVAL;
		memset(&f->fmt.pix, 0, sizeof(struct v4l2_pix_format));
		f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
		switch (meye.mchip_mode) {
		case MCHIP_HIC_MODE_CONT_OUT:
		default:
			f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
			break;
		case MCHIP_HIC_MODE_CONT_COMP:
			f->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
			break;
		}
		f->fmt.pix.field = V4L2_FIELD_NONE;
		f->fmt.pix.width = mchip_hsize();
		f->fmt.pix.height = mchip_vsize();
		f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
		f->fmt.pix.sizeimage = f->fmt.pix.height *
				       f->fmt.pix.bytesperline;
		f->fmt.pix.colorspace = 0;
		f->fmt.pix.priv = 0;
		break;
	}

	case VIDIOC_S_FMT: {
		struct v4l2_format *f = arg;

		if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
			return -EINVAL;
		if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
		    f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
			return -EINVAL;
		if (f->fmt.pix.field != V4L2_FIELD_ANY &&
		    f->fmt.pix.field != V4L2_FIELD_NONE)
			return -EINVAL;
		f->fmt.pix.field = V4L2_FIELD_NONE;
		down(&meye.lock);
		if (f->fmt.pix.width <= 320) {
			f->fmt.pix.width = 320;
			f->fmt.pix.height = 240;
			meye.params.subsample = 1;
		} else {
			f->fmt.pix.width = 640;
			f->fmt.pix.height = 480;
			meye.params.subsample = 0;
		}
		switch (f->fmt.pix.pixelformat) {
		case V4L2_PIX_FMT_YUYV:
			meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
			break;
		case V4L2_PIX_FMT_MJPEG:
			meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
			break;
		}
		up(&meye.lock);
		f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
		f->fmt.pix.sizeimage = f->fmt.pix.height *
				       f->fmt.pix.bytesperline;
		f->fmt.pix.colorspace = 0;
		f->fmt.pix.priv = 0;

		break;
	}

	case VIDIOC_REQBUFS: {
		struct v4l2_requestbuffers *req = arg;
		int i;

		if (req->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
			return -EINVAL;
		if (req->memory != V4L2_MEMORY_MMAP)
			return -EINVAL;
		if (meye.grab_fbuffer && req->count == gbuffers) {
			/* already allocated, no modifications */
			break;
		}
		down(&meye.lock);
		if (meye.grab_fbuffer) {
			for (i = 0; i < gbuffers; i++)
				if (meye.vma_use_count[i]) {
					up(&meye.lock);
					return -EINVAL;
				}
			rvfree(meye.grab_fbuffer, gbuffers * gbufsize);
			meye.grab_fbuffer = NULL;
		}
		gbuffers = max(2, min((int)req->count, MEYE_MAX_BUFNBRS));
		req->count = gbuffers;
		meye.grab_fbuffer = rvmalloc(gbuffers * gbufsize);
		if (!meye.grab_fbuffer) {
			printk(KERN_ERR "meye: v4l framebuffer allocation"
					" failed\n");
			up(&meye.lock);
			return -ENOMEM;
		}
		for (i = 0; i < gbuffers; i++)
			meye.vma_use_count[i] = 0;
		up(&meye.lock);