openkylin
/
linux
mirror of https://gitee.com/openkylin/linux.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

[media] Staging: tm6000: fix braces, tabs, comments and space coding style issue in tm6000-video.c 

This is a patch to the tm6000-video.c file that fixed
up a braces, tabs, comments and space Errors and Warnings found by the checkpatch.pl tools.

[mchehab@redhat.com: some changes didn't apply as it were based to an older version, so used patch -f to apply only the changes that are OK]
Signed-off-by: Ruslan Pisarev <ruslan@rpisarev.org.ua>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
This commit is contained in:
Ruslan Pisarev 2010-10-20 06:35:12 -03:00 committed by Mauro Carvalho Chehab
parent d7fe4a602d
commit 60fbfdfd8c
1 changed files with 173 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

345
drivers/staging/tm6000/tm6000-video.c
View File

@ -1,23 +1,23 @@
/* /*
tm6000-video.c - driver for TM5600/TM6000/TM6010 USB video capture devices * tm6000-video.c - driver for TM5600/TM6000/TM6010 USB video capture devices
*
Copyright (C) 2006-2007 Mauro Carvalho Chehab <mchehab@infradead.org> * Copyright (C) 2006-2007 Mauro Carvalho Chehab <mchehab@infradead.org>
*
Copyright (C) 2007 Michel Ludwig <michel.ludwig@gmail.com> * Copyright (C) 2007 Michel Ludwig <michel.ludwig@gmail.com>
- Fixed module load/unload * - Fixed module load/unload
*
This program is free software; you can redistribute it and/or modify * This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
the Free Software Foundation version 2 * the Free Software Foundation version 2
*
This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. * GNU General Public License for more details.
*
You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software * along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/ */
#include <linux/module.h> #include <linux/module.h>
#include <linux/delay.h> #include <linux/delay.h>
@ -118,8 +118,9 @@ static struct tm6000_fmt format[] = {
}; };
/* ------------------------------------------------------------------ /* ------------------------------------------------------------------
DMA and thread functions * DMA and thread functions
------------------------------------------------------------------*/ * ------------------------------------------------------------------
*/
#define norm_maxw(a) 720 #define norm_maxw(a) 720
#define norm_maxh(a) 576 #define norm_maxh(a) 576
@ -189,17 +190,17 @@ static int copy_streams(u8 *data, unsigned long len,
struct urb *urb) struct urb *urb)
{ {
struct tm6000_dmaqueue *dma_q = urb->context; struct tm6000_dmaqueue *dma_q = urb->context;
struct tm6000_core *dev= container_of(dma_q,struct tm6000_core,vidq); struct tm6000_core *dev = container_of(dma_q, struct tm6000_core, vidq);
u8 *ptr=data, *endp=data+len, c; u8 *ptr = data, *endp = data+len, c;
unsigned long header=0; unsigned long header = 0;
int rc=0; int rc = 0;
unsigned int cmd, cpysize, pktsize, size, field, block, line, pos = 0; unsigned int cmd, cpysize, pktsize, size, field, block, line, pos = 0;
struct tm6000_buffer *vbuf; struct tm6000_buffer *vbuf;
char *voutp = NULL; char *voutp = NULL;
unsigned int linewidth; unsigned int linewidth;
/* get video buffer */ /* get video buffer */
get_next_buf (dma_q, &vbuf); get_next_buf(dma_q, &vbuf);
if (!vbuf) if (!vbuf)
return rc; return rc;
voutp = videobuf_to_vmalloc(&vbuf->vb); voutp = videobuf_to_vmalloc(&vbuf->vb);
@ -213,7 +214,7 @@ static int copy_streams(u8 *data, unsigned long len,
/* from last urb or packet */ /* from last urb or packet */
header = dev->isoc_ctl.tmp_buf; header = dev->isoc_ctl.tmp_buf;
if (4 - dev->isoc_ctl.tmp_buf_len > 0) { if (4 - dev->isoc_ctl.tmp_buf_len > 0) {
memcpy ((u8 *)&header + memcpy((u8 *)&header +
dev->isoc_ctl.tmp_buf_len, dev->isoc_ctl.tmp_buf_len,
ptr, ptr,
4 - dev->isoc_ctl.tmp_buf_len); 4 - dev->isoc_ctl.tmp_buf_len);
@ -224,7 +225,7 @@ static int copy_streams(u8 *data, unsigned long len,
if (ptr + 3 >= endp) { if (ptr + 3 >= endp) {
/* have incomplete header */ /* have incomplete header */
dev->isoc_ctl.tmp_buf_len = endp - ptr; dev->isoc_ctl.tmp_buf_len = endp - ptr;
memcpy (&dev->isoc_ctl.tmp_buf, ptr, memcpy(&dev->isoc_ctl.tmp_buf, ptr,
dev->isoc_ctl.tmp_buf_len); dev->isoc_ctl.tmp_buf_len);
return rc; return rc;
} }
@ -261,13 +262,13 @@ static int copy_streams(u8 *data, unsigned long len,
/* Announces that a new buffer /* Announces that a new buffer
* were filled * were filled
*/ */
buffer_filled (dev, dma_q, vbuf); buffer_filled(dev, dma_q, vbuf);
dprintk (dev, V4L2_DEBUG_ISOC, dprintk(dev, V4L2_DEBUG_ISOC,
"new buffer filled\n"); "new buffer filled\n");
get_next_buf (dma_q, &vbuf); get_next_buf(dma_q, &vbuf);
if (!vbuf) if (!vbuf)
return rc; return rc;
voutp = videobuf_to_vmalloc (&vbuf->vb); voutp = videobuf_to_vmalloc(&vbuf->vb);
if (!voutp) if (!voutp)
return rc; return rc;
memset(voutp, 0, vbuf->vb.size); memset(voutp, 0, vbuf->vb.size);
@ -301,7 +302,7 @@ static int copy_streams(u8 *data, unsigned long len,
case TM6000_URB_MSG_VIDEO: case TM6000_URB_MSG_VIDEO:
/* Fills video buffer */ /* Fills video buffer */
if (vbuf) if (vbuf)
memcpy (&voutp[pos], ptr, cpysize); memcpy(&voutp[pos], ptr, cpysize);
break; break;
case TM6000_URB_MSG_AUDIO: case TM6000_URB_MSG_AUDIO:
/* Need some code to copy audio buffer */ /* Need some code to copy audio buffer */
@ -346,9 +347,9 @@ static int copy_multiplexed(u8 *ptr, unsigned long len,
struct urb *urb) struct urb *urb)
{ {
struct tm6000_dmaqueue *dma_q = urb->context; struct tm6000_dmaqueue *dma_q = urb->context;
struct tm6000_core *dev= container_of(dma_q,struct tm6000_core,vidq); struct tm6000_core *dev = container_of(dma_q, struct tm6000_core, vidq);
unsigned int pos=dev->isoc_ctl.pos,cpysize; unsigned int pos = dev->isoc_ctl.pos, cpysize;
int rc=1; int rc = 1;
struct tm6000_buffer *buf; struct tm6000_buffer *buf;
char *outp = NULL; char *outp = NULL;
@ -359,19 +360,18 @@ static int copy_multiplexed(u8 *ptr, unsigned long len,
if (!outp) if (!outp)
return 0; return 0;
while (len>0) { while (len > 0) {
cpysize=min(len,buf->vb.size-pos); cpysize = min(len, buf->vb.size-pos);
//printk("Copying %d bytes (max=%lu) from %p to %p[%u]\n",cpysize,(*buf)->vb.size,ptr,out_p,pos);
memcpy(&outp[pos], ptr, cpysize); memcpy(&outp[pos], ptr, cpysize);
pos+=cpysize; pos += cpysize;
ptr+=cpysize; ptr += cpysize;
len-=cpysize; len -= cpysize;
if (pos >= buf->vb.size) { if (pos >= buf->vb.size) {
pos=0; pos = 0;
/* Announces that a new buffer were filled */ /* Announces that a new buffer were filled */
buffer_filled (dev, dma_q, buf); buffer_filled(dev, dma_q, buf);
dprintk(dev, V4L2_DEBUG_ISOC, "new buffer filled\n"); dprintk(dev, V4L2_DEBUG_ISOC, "new buffer filled\n");
get_next_buf (dma_q, &buf); get_next_buf(dma_q, &buf);
if (!buf) if (!buf)
break; break;
outp = videobuf_to_vmalloc(&(buf->vb)); outp = videobuf_to_vmalloc(&(buf->vb));
@ -381,16 +381,16 @@ static int copy_multiplexed(u8 *ptr, unsigned long len,
} }
} }
dev->isoc_ctl.pos=pos; dev->isoc_ctl.pos = pos;
return rc; return rc;
} }
static void inline print_err_status (struct tm6000_core *dev, static inline void print_err_status(struct tm6000_core *dev,
int packet, int status) int packet, int status)
{ {
char *errmsg = "Unknown"; char *errmsg = "Unknown";
switch(status) { switch (status) {
case -ENOENT: case -ENOENT:
errmsg = "unlinked synchronuously"; errmsg = "unlinked synchronuously";
break; break;
@ -416,7 +416,7 @@ static void inline print_err_status (struct tm6000_core *dev,
errmsg = "Device does not respond"; errmsg = "Device does not respond";
break; break;
} }
if (packet<0) { if (packet < 0) {
dprintk(dev, V4L2_DEBUG_QUEUE, "URB status %d [%s].\n", dprintk(dev, V4L2_DEBUG_QUEUE, "URB status %d [%s].\n",
status, errmsg); status, errmsg);
} else { } else {
@ -432,20 +432,20 @@ static void inline print_err_status (struct tm6000_core *dev,
static inline int tm6000_isoc_copy(struct urb *urb) static inline int tm6000_isoc_copy(struct urb *urb)
{ {
struct tm6000_dmaqueue *dma_q = urb->context; struct tm6000_dmaqueue *dma_q = urb->context;
struct tm6000_core *dev= container_of(dma_q,struct tm6000_core,vidq); struct tm6000_core *dev = container_of(dma_q, struct tm6000_core, vidq);
int i, len=0, rc=1, status; int i, len = 0, rc = 1, status;
char *p; char *p;
if (urb->status < 0) { if (urb->status < 0) {
print_err_status (dev, -1, urb->status); print_err_status(dev, -1, urb->status);
return 0; return 0;
} }
for (i = 0; i < urb->number_of_packets; i++) { for (i = 0; i < urb->number_of_packets; i++) {
status = urb->iso_frame_desc[i].status; status = urb->iso_frame_desc[i].status;
if (status<0) { if (status < 0) {
print_err_status (dev,i,status); print_err_status(dev, i, status);
continue; continue;
} }
@ -454,9 +454,9 @@ static inline int tm6000_isoc_copy(struct urb *urb)
if (len > 0) { if (len > 0) {
p = urb->transfer_buffer + urb->iso_frame_desc[i].offset; p = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
if (!urb->iso_frame_desc[i].status) { if (!urb->iso_frame_desc[i].status) {
if ((dev->fourcc)==V4L2_PIX_FMT_TM6000) { if ((dev->fourcc) == V4L2_PIX_FMT_TM6000) {
rc=copy_multiplexed(p, len, urb); rc = copy_multiplexed(p, len, urb);
if (rc<=0) if (rc <= 0)
return rc; return rc;
} else { } else {
copy_streams(p, len, urb); copy_streams(p, len, urb);
@ -468,8 +468,9 @@ static inline int tm6000_isoc_copy(struct urb *urb)
} }
/* ------------------------------------------------------------------ /* ------------------------------------------------------------------
URB control * URB control
------------------------------------------------------------------*/ * ------------------------------------------------------------------
*/
/* /*
* IRQ callback, called by URB callback * IRQ callback, called by URB callback
@ -509,7 +510,7 @@ static void tm6000_uninit_isoc(struct tm6000_core *dev)
dev->isoc_ctl.buf = NULL; dev->isoc_ctl.buf = NULL;
for (i = 0; i < dev->isoc_ctl.num_bufs; i++) { for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
urb=dev->isoc_ctl.urb[i]; urb = dev->isoc_ctl.urb[i];
if (urb) { if (urb) {
usb_kill_urb(urb); usb_kill_urb(urb);
usb_unlink_urb(urb); usb_unlink_urb(urb);
@ -525,11 +526,11 @@ static void tm6000_uninit_isoc(struct tm6000_core *dev)
dev->isoc_ctl.transfer_buffer[i] = NULL; dev->isoc_ctl.transfer_buffer[i] = NULL;
} }
kfree (dev->isoc_ctl.urb); kfree(dev->isoc_ctl.urb);
kfree (dev->isoc_ctl.transfer_buffer); kfree(dev->isoc_ctl.transfer_buffer);
dev->isoc_ctl.urb=NULL; dev->isoc_ctl.urb = NULL;
dev->isoc_ctl.transfer_buffer=NULL; dev->isoc_ctl.transfer_buffer = NULL;
dev->isoc_ctl.num_bufs = 0; dev->isoc_ctl.num_bufs = 0;
} }
@ -560,7 +561,7 @@ static int tm6000_prepare_isoc(struct tm6000_core *dev, unsigned int framesize)
dev->isoc_ctl.max_pkt_size = size; dev->isoc_ctl.max_pkt_size = size;
max_packets = ( framesize + size - 1) / size; max_packets = (framesize + size - 1) / size;
if (max_packets > TM6000_MAX_ISO_PACKETS) if (max_packets > TM6000_MAX_ISO_PACKETS)
max_packets = TM6000_MAX_ISO_PACKETS; max_packets = TM6000_MAX_ISO_PACKETS;
@ -602,10 +603,10 @@ static int tm6000_prepare_isoc(struct tm6000_core *dev, unsigned int framesize)
dev->isoc_ctl.transfer_buffer[i] = usb_alloc_coherent(dev->udev, dev->isoc_ctl.transfer_buffer[i] = usb_alloc_coherent(dev->udev,
sb_size, GFP_KERNEL, &urb->transfer_dma); sb_size, GFP_KERNEL, &urb->transfer_dma);
if (!dev->isoc_ctl.transfer_buffer[i]) { if (!dev->isoc_ctl.transfer_buffer[i]) {
tm6000_err ("unable to allocate %i bytes for transfer" tm6000_err("unable to allocate %i bytes for transfer"
" buffer %i%s\n", " buffer %i%s\n",
sb_size, i, sb_size, i,
in_interrupt()?" while in int":""); in_interrupt() ? " while in int" : "");
tm6000_uninit_isoc(dev); tm6000_uninit_isoc(dev);
return -ENOMEM; return -ENOMEM;
} }
@ -627,13 +628,13 @@ static int tm6000_prepare_isoc(struct tm6000_core *dev, unsigned int framesize)
return 0; return 0;
} }
static int tm6000_start_thread( struct tm6000_core *dev) static int tm6000_start_thread(struct tm6000_core *dev)
{ {
struct tm6000_dmaqueue *dma_q = &dev->vidq; struct tm6000_dmaqueue *dma_q = &dev->vidq;
int i; int i;
dma_q->frame=0; dma_q->frame = 0;
dma_q->ini_jiffies=jiffies; dma_q->ini_jiffies = jiffies;
init_waitqueue_head(&dma_q->wq); init_waitqueue_head(&dma_q->wq);
@ -652,8 +653,9 @@ static int tm6000_start_thread( struct tm6000_core *dev)
} }
/* ------------------------------------------------------------------ /* ------------------------------------------------------------------
Videobuf operations * Videobuf operations
------------------------------------------------------------------*/ * ------------------------------------------------------------------
*/
static int static int
buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size) buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size)
@ -664,9 +666,8 @@ buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size)
if (0 == *count) if (0 == *count)
*count = TM6000_DEF_BUF; *count = TM6000_DEF_BUF;
if (*count < TM6000_MIN_BUF) { if (*count < TM6000_MIN_BUF)
*count=TM6000_MIN_BUF; *count = TM6000_MIN_BUF;
}
while (*size * *count > vid_limit * 1024 * 1024) while (*size * *count > vid_limit * 1024 * 1024)
(*count)--; (*count)--;
@ -706,7 +707,7 @@ buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
enum v4l2_field field) enum v4l2_field field)
{ {
struct tm6000_fh *fh = vq->priv_data; struct tm6000_fh *fh = vq->priv_data;
struct tm6000_buffer *buf = container_of(vb,struct tm6000_buffer,vb); struct tm6000_buffer *buf = container_of(vb, struct tm6000_buffer, vb);
struct tm6000_core *dev = fh->dev; struct tm6000_core *dev = fh->dev;
int rc = 0, urb_init = 0; int rc = 0, urb_init = 0;
@ -761,7 +762,7 @@ buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
static void static void
buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb) buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
{ {
struct tm6000_buffer *buf = container_of(vb,struct tm6000_buffer,vb); struct tm6000_buffer *buf = container_of(vb, struct tm6000_buffer, vb);
struct tm6000_fh *fh = vq->priv_data; struct tm6000_fh *fh = vq->priv_data;
struct tm6000_core *dev = fh->dev; struct tm6000_core *dev = fh->dev;
struct tm6000_dmaqueue *vidq = &dev->vidq; struct tm6000_dmaqueue *vidq = &dev->vidq;
@ -772,9 +773,9 @@ buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
static void buffer_release(struct videobuf_queue *vq, struct videobuf_buffer *vb) static void buffer_release(struct videobuf_queue *vq, struct videobuf_buffer *vb)
{ {
struct tm6000_buffer *buf = container_of(vb,struct tm6000_buffer,vb); struct tm6000_buffer *buf = container_of(vb, struct tm6000_buffer, vb);
free_buffer(vq,buf); free_buffer(vq, buf);
} }
static struct videobuf_queue_ops tm6000_video_qops = { static struct videobuf_queue_ops tm6000_video_qops = {
@ -785,8 +786,9 @@ static struct videobuf_queue_ops tm6000_video_qops = {
}; };
/* ------------------------------------------------------------------ /* ------------------------------------------------------------------
IOCTL handling * IOCTL handling
------------------------------------------------------------------*/ * ------------------------------------------------------------------
*/
static bool is_res_read(struct tm6000_core *dev, struct tm6000_fh *fh) static bool is_res_read(struct tm6000_core *dev, struct tm6000_fh *fh)
{ {
@ -835,16 +837,15 @@ static void res_free(struct tm6000_core *dev, struct tm6000_fh *fh)
} }
/* ------------------------------------------------------------------ /* ------------------------------------------------------------------
IOCTL vidioc handling * IOCTL vidioc handling
------------------------------------------------------------------*/ * ------------------------------------------------------------------
static int vidioc_querycap (struct file *file, void *priv, */
static int vidioc_querycap(struct file *file, void *priv,
struct v4l2_capability *cap) struct v4l2_capability *cap)
{ {
// struct tm6000_core *dev = ((struct tm6000_fh *)priv)->dev;
strlcpy(cap->driver, "tm6000", sizeof(cap->driver)); strlcpy(cap->driver, "tm6000", sizeof(cap->driver));
strlcpy(cap->card,"Trident TVMaster TM5600/6000/6010", sizeof(cap->card)); strlcpy(cap->card, "Trident TVMaster TM5600/6000/6010", sizeof(cap->card));
// strlcpy(cap->bus_info, dev->udev->dev.bus_id, sizeof(cap->bus_info));
cap->version = TM6000_VERSION; cap->version = TM6000_VERSION;
cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
V4L2_CAP_STREAMING | V4L2_CAP_STREAMING |
@ -853,21 +854,21 @@ static int vidioc_querycap (struct file *file, void *priv,
return 0; return 0;
} }
static int vidioc_enum_fmt_vid_cap (struct file *file, void *priv, static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
struct v4l2_fmtdesc *f) struct v4l2_fmtdesc *f)
{ {
if (unlikely(f->index >= ARRAY_SIZE(format))) if (unlikely(f->index >= ARRAY_SIZE(format)))
return -EINVAL; return -EINVAL;
strlcpy(f->description,format[f->index].name,sizeof(f->description)); strlcpy(f->description, format[f->index].name, sizeof(f->description));
f->pixelformat = format[f->index].fourcc; f->pixelformat = format[f->index].fourcc;
return 0; return 0;
} }
static int vidioc_g_fmt_vid_cap (struct file *file, void *priv, static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
struct v4l2_format *f) struct v4l2_format *f)
{ {
struct tm6000_fh *fh=priv; struct tm6000_fh *fh = priv;
f->fmt.pix.width = fh->width; f->fmt.pix.width = fh->width;
f->fmt.pix.height = fh->height; f->fmt.pix.height = fh->height;
@ -878,10 +879,10 @@ static int vidioc_g_fmt_vid_cap (struct file *file, void *priv,
f->fmt.pix.sizeimage = f->fmt.pix.sizeimage =
f->fmt.pix.height * f->fmt.pix.bytesperline; f->fmt.pix.height * f->fmt.pix.bytesperline;
return (0); return 0;
} }
static struct tm6000_fmt* format_by_fourcc(unsigned int fourcc) static struct tm6000_fmt *format_by_fourcc(unsigned int fourcc)
{ {
unsigned int i; unsigned int i;
@ -891,7 +892,7 @@ static struct tm6000_fmt* format_by_fourcc(unsigned int fourcc)
return NULL; return NULL;
} }
static int vidioc_try_fmt_vid_cap (struct file *file, void *priv, static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
struct v4l2_format *f) struct v4l2_format *f)
{ {
struct tm6000_core *dev = ((struct tm6000_fh *)priv)->dev; struct tm6000_core *dev = ((struct tm6000_fh *)priv)->dev;
@ -907,15 +908,14 @@ static int vidioc_try_fmt_vid_cap (struct file *file, void *priv,
field = f->fmt.pix.field; field = f->fmt.pix.field;
if (field == V4L2_FIELD_ANY) { if (field == V4L2_FIELD_ANY)
// field=V4L2_FIELD_INTERLACED; field = V4L2_FIELD_SEQ_TB;
field=V4L2_FIELD_SEQ_TB; else if (V4L2_FIELD_INTERLACED != field) {
} else if (V4L2_FIELD_INTERLACED != field) {
dprintk(dev, V4L2_DEBUG_IOCTL_ARG, "Field type invalid.\n"); dprintk(dev, V4L2_DEBUG_IOCTL_ARG, "Field type invalid.\n");
return -EINVAL; return -EINVAL;
} }
tm6000_get_std_res (dev); tm6000_get_std_res(dev);
f->fmt.pix.width = dev->width; f->fmt.pix.width = dev->width;
f->fmt.pix.height = dev->height; f->fmt.pix.height = dev->height;
@ -933,14 +933,14 @@ static int vidioc_try_fmt_vid_cap (struct file *file, void *priv,
} }
/*FIXME: This seems to be generic enough to be at videodev2 */ /*FIXME: This seems to be generic enough to be at videodev2 */
static int vidioc_s_fmt_vid_cap (struct file *file, void *priv, static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
struct v4l2_format *f) struct v4l2_format *f)
{ {
struct tm6000_fh *fh=priv; struct tm6000_fh *fh = priv;
struct tm6000_core *dev = fh->dev; struct tm6000_core *dev = fh->dev;
int ret = vidioc_try_fmt_vid_cap(file,fh,f); int ret = vidioc_try_fmt_vid_cap(file, fh, f);
if (ret < 0) if (ret < 0)
return (ret); return ret;
fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat); fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat);
fh->width = f->fmt.pix.width; fh->width = f->fmt.pix.width;
@ -952,52 +952,52 @@ static int vidioc_s_fmt_vid_cap (struct file *file, void *priv,
tm6000_set_fourcc_format(dev); tm6000_set_fourcc_format(dev);
return (0); return 0;
} }
static int vidioc_reqbufs (struct file *file, void *priv, static int vidioc_reqbufs(struct file *file, void *priv,
struct v4l2_requestbuffers *p) struct v4l2_requestbuffers *p)
{ {
struct tm6000_fh *fh=priv; struct tm6000_fh *fh = priv;
return (videobuf_reqbufs(&fh->vb_vidq, p)); return videobuf_reqbufs(&fh->vb_vidq, p);
} }
static int vidioc_querybuf (struct file *file, void *priv, static int vidioc_querybuf(struct file *file, void *priv,
struct v4l2_buffer *p) struct v4l2_buffer *p)
{ {
struct tm6000_fh *fh=priv; struct tm6000_fh *fh = priv;
return (videobuf_querybuf(&fh->vb_vidq, p)); return videobuf_querybuf(&fh->vb_vidq, p);
} }
static int vidioc_qbuf (struct file *file, void *priv, struct v4l2_buffer *p) static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
{ {
struct tm6000_fh *fh=priv; struct tm6000_fh *fh = priv;
return (videobuf_qbuf(&fh->vb_vidq, p)); return videobuf_qbuf(&fh->vb_vidq, p);
} }
static int vidioc_dqbuf (struct file *file, void *priv, struct v4l2_buffer *p) static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
{ {
struct tm6000_fh *fh=priv; struct tm6000_fh *fh = priv;
return (videobuf_dqbuf(&fh->vb_vidq, p, return videobuf_dqbuf(&fh->vb_vidq, p,
file->f_flags & O_NONBLOCK)); file->f_flags & O_NONBLOCK);
} }
#ifdef CONFIG_VIDEO_V4L1_COMPAT #ifdef CONFIG_VIDEO_V4L1_COMPAT
static int vidiocgmbuf (struct file *file, void *priv, struct video_mbuf *mbuf) static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
{ {
struct tm6000_fh *fh=priv; struct tm6000_fh *fh = priv;
return videobuf_cgmbuf (&fh->vb_vidq, mbuf, 8); return videobuf_cgmbuf(&fh->vb_vidq, mbuf, 8);
} }
#endif #endif
static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i) static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
{ {
struct tm6000_fh *fh=priv; struct tm6000_fh *fh = priv;
struct tm6000_core *dev = fh->dev; struct tm6000_core *dev = fh->dev;
if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
@ -1045,21 +1045,21 @@ static int vidioc_s_std (struct file *file, void *priv, v4l2_std_id *norm)
return 0; return 0;
} }
static int vidioc_enum_input (struct file *file, void *priv, static int vidioc_enum_input(struct file *file, void *priv,
struct v4l2_input *inp) struct v4l2_input *inp)
{ {
switch (inp->index) { switch (inp->index) {
case TM6000_INPUT_TV: case TM6000_INPUT_TV:
inp->type = V4L2_INPUT_TYPE_TUNER; inp->type = V4L2_INPUT_TYPE_TUNER;
strcpy(inp->name,"Television"); strcpy(inp->name, "Television");
break; break;
case TM6000_INPUT_COMPOSITE: case TM6000_INPUT_COMPOSITE:
inp->type = V4L2_INPUT_TYPE_CAMERA; inp->type = V4L2_INPUT_TYPE_CAMERA;
strcpy(inp->name,"Composite"); strcpy(inp->name, "Composite");
break; break;
case TM6000_INPUT_SVIDEO: case TM6000_INPUT_SVIDEO:
inp->type = V4L2_INPUT_TYPE_CAMERA; inp->type = V4L2_INPUT_TYPE_CAMERA;
strcpy(inp->name,"S-Video"); strcpy(inp->name, "S-Video");
break; break;
default: default:
return -EINVAL; return -EINVAL;
@ -1069,48 +1069,48 @@ static int vidioc_enum_input (struct file *file, void *priv,
return 0; return 0;
} }
static int vidioc_g_input (struct file *file, void *priv, unsigned int *i) static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
{ {
struct tm6000_fh *fh=priv; struct tm6000_fh *fh = priv;
struct tm6000_core *dev = fh->dev; struct tm6000_core *dev = fh->dev;
*i=dev->input; *i = dev->input;
return 0; return 0;
} }
static int vidioc_s_input (struct file *file, void *priv, unsigned int i) static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
{ {
struct tm6000_fh *fh=priv; struct tm6000_fh *fh = priv;
struct tm6000_core *dev = fh->dev; struct tm6000_core *dev = fh->dev;
int rc=0; int rc = 0;
char buf[1]; char buf[1];
switch (i) { switch (i) {
case TM6000_INPUT_TV: case TM6000_INPUT_TV:
dev->input=i; dev->input = i;
*buf=0; *buf = 0;
break; break;
case TM6000_INPUT_COMPOSITE: case TM6000_INPUT_COMPOSITE:
case TM6000_INPUT_SVIDEO: case TM6000_INPUT_SVIDEO:
dev->input=i; dev->input = i;
*buf=1; *buf = 1;
break; break;
default: default:
return -EINVAL; return -EINVAL;
} }
rc=tm6000_read_write_usb (dev, USB_DIR_OUT | USB_TYPE_VENDOR, rc = tm6000_read_write_usb(dev, USB_DIR_OUT | USB_TYPE_VENDOR,
REQ_03_SET_GET_MCU_PIN, 0x03, 1, buf, 1); REQ_03_SET_GET_MCU_PIN, 0x03, 1, buf, 1);
if (!rc) { if (!rc) {
dev->input=i; dev->input = i;
rc=vidioc_s_std (file, priv, &dev->vfd->current_norm); rc = vidioc_s_std(file, priv, &dev->vfd->current_norm);
} }
return (rc); return rc;
} }
/* --- controls ---------------------------------------------- */ /* --- controls ---------------------------------------------- */
static int vidioc_queryctrl (struct file *file, void *priv, static int vidioc_queryctrl(struct file *file, void *priv,
struct v4l2_queryctrl *qc) struct v4l2_queryctrl *qc)
{ {
int i; int i;
@ -1119,16 +1119,16 @@ static int vidioc_queryctrl (struct file *file, void *priv,
if (qc->id && qc->id == tm6000_qctrl[i].id) { if (qc->id && qc->id == tm6000_qctrl[i].id) {
memcpy(qc, &(tm6000_qctrl[i]), memcpy(qc, &(tm6000_qctrl[i]),
sizeof(*qc)); sizeof(*qc));
return (0); return 0;
} }
return -EINVAL; return -EINVAL;
} }
static int vidioc_g_ctrl (struct file *file, void *priv, static int vidioc_g_ctrl(struct file *file, void *priv,
struct v4l2_control *ctrl) struct v4l2_control *ctrl)
{ {
struct tm6000_fh *fh=priv; struct tm6000_fh *fh = priv;
struct tm6000_core *dev = fh->dev; struct tm6000_core *dev = fh->dev;
int val; int val;
@ -1150,41 +1150,41 @@ static int vidioc_g_ctrl (struct file *file, void *priv,
return -EINVAL; return -EINVAL;
} }
if (val<0) if (val < 0)
return val; return val;
ctrl->value=val; ctrl->value = val;
return 0; return 0;
} }
static int vidioc_s_ctrl (struct file *file, void *priv, static int vidioc_s_ctrl(struct file *file, void *priv,
struct v4l2_control *ctrl) struct v4l2_control *ctrl)
{ {
struct tm6000_fh *fh =priv; struct tm6000_fh *fh = priv;
struct tm6000_core *dev = fh->dev; struct tm6000_core *dev = fh->dev;
u8 val=ctrl->value; u8 val = ctrl->value;
switch (ctrl->id) { switch (ctrl->id) {
case V4L2_CID_CONTRAST: case V4L2_CID_CONTRAST:
tm6000_set_reg(dev, TM6010_REQ07_R08_LUMA_CONTRAST_ADJ, val); tm6000_set_reg(dev, TM6010_REQ07_R08_LUMA_CONTRAST_ADJ, val);
return 0; return 0;
case V4L2_CID_BRIGHTNESS: case V4L2_CID_BRIGHTNESS:
tm6000_set_reg(dev, TM6010_REQ07_R09_LUMA_BRIGHTNESS_ADJ, val); tm6000_set_reg(dev, TM6010_REQ07_R09_LUMA_BRIGHTNESS_ADJ, val);
return 0; return 0;
case V4L2_CID_SATURATION: case V4L2_CID_SATURATION:
tm6000_set_reg(dev, TM6010_REQ07_R0A_CHROMA_SATURATION_ADJ, val); tm6000_set_reg(dev, TM6010_REQ07_R0A_CHROMA_SATURATION_ADJ, val);
return 0; return 0;
case V4L2_CID_HUE: case V4L2_CID_HUE:
tm6000_set_reg(dev, TM6010_REQ07_R0B_CHROMA_HUE_PHASE_ADJ, val); tm6000_set_reg(dev, TM6010_REQ07_R0B_CHROMA_HUE_PHASE_ADJ, val);
return 0; return 0;
} }
return -EINVAL; return -EINVAL;
} }
static int vidioc_g_tuner (struct file *file, void *priv, static int vidioc_g_tuner(struct file *file, void *priv,
struct v4l2_tuner *t) struct v4l2_tuner *t)
{ {
struct tm6000_fh *fh =priv; struct tm6000_fh *fh = priv;
struct tm6000_core *dev = fh->dev; struct tm6000_core *dev = fh->dev;
if (unlikely(UNSET == dev->tuner_type)) if (unlikely(UNSET == dev->tuner_type))
@ -1201,10 +1201,10 @@ static int vidioc_g_tuner (struct file *file, void *priv,
return 0; return 0;
} }
static int vidioc_s_tuner (struct file *file, void *priv, static int vidioc_s_tuner(struct file *file, void *priv,
struct v4l2_tuner *t) struct v4l2_tuner *t)
{ {
struct tm6000_fh *fh =priv; struct tm6000_fh *fh = priv;
struct tm6000_core *dev = fh->dev; struct tm6000_core *dev = fh->dev;
if (UNSET == dev->tuner_type) if (UNSET == dev->tuner_type)
@ -1215,10 +1215,10 @@ static int vidioc_s_tuner (struct file *file, void *priv,
return 0; return 0;
} }
static int vidioc_g_frequency (struct file *file, void *priv, static int vidioc_g_frequency(struct file *file, void *priv,
struct v4l2_frequency *f) struct v4l2_frequency *f)
{ {
struct tm6000_fh *fh =priv; struct tm6000_fh *fh = priv;
struct tm6000_core *dev = fh->dev; struct tm6000_core *dev = fh->dev;
if (unlikely(UNSET == dev->tuner_type)) if (unlikely(UNSET == dev->tuner_type))
@ -1232,10 +1232,10 @@ static int vidioc_g_frequency (struct file *file, void *priv,
return 0; return 0;
} }
static int vidioc_s_frequency (struct file *file, void *priv, static int vidioc_s_frequency(struct file *file, void *priv,
struct v4l2_frequency *f) struct v4l2_frequency *f)
{ {
struct tm6000_fh *fh =priv; struct tm6000_fh *fh = priv;
struct tm6000_core *dev = fh->dev; struct tm6000_core *dev = fh->dev;
if (unlikely(f->type != V4L2_TUNER_ANALOG_TV)) if (unlikely(f->type != V4L2_TUNER_ANALOG_TV))
@ -1262,7 +1262,7 @@ static int tm6000_open(struct file *file)
struct tm6000_core *dev = video_drvdata(file); struct tm6000_core *dev = video_drvdata(file);
struct tm6000_fh *fh; struct tm6000_fh *fh;
enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE; enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
int i,rc; int i, rc;
printk(KERN_INFO "tm6000: open called (dev=%s)\n", printk(KERN_INFO "tm6000: open called (dev=%s)\n",
video_device_node_name(vdev)); video_device_node_name(vdev));
@ -1279,7 +1279,7 @@ static int tm6000_open(struct file *file)
dev->users); dev->users);
/* allocate + initialize per filehandle data */ /* allocate + initialize per filehandle data */
fh = kzalloc(sizeof(*fh),GFP_KERNEL); fh = kzalloc(sizeof(*fh), GFP_KERNEL);
if (NULL == fh) { if (NULL == fh) {
dev->users--; dev->users--;
return -ENOMEM; return -ENOMEM;
@ -1368,7 +1368,7 @@ tm6000_poll(struct file *file, struct poll_table_struct *wait)
poll_wait(file, &buf->vb.done, wait); poll_wait(file, &buf->vb.done, wait);
if (buf->vb.state == VIDEOBUF_DONE || if (buf->vb.state == VIDEOBUF_DONE ||
buf->vb.state == VIDEOBUF_ERROR) buf->vb.state == VIDEOBUF_ERROR)
return POLLIN|POLLRDNORM; return POLLIN | POLLRDNORM;
return 0; return 0;
} }
@ -1389,7 +1389,7 @@ static int tm6000_release(struct file *file)
videobuf_mmap_free(&fh->vb_vidq); videobuf_mmap_free(&fh->vb_vidq);
} }
kfree (fh); kfree(fh);
return 0; return 0;
} }
@ -1399,7 +1399,7 @@ static int tm6000_mmap(struct file *file, struct vm_area_struct * vma)
struct tm6000_fh *fh = file->private_data; struct tm6000_fh *fh = file->private_data;
int ret; int ret;
ret=videobuf_mmap_mapper(&fh->vb_vidq, vma); ret = videobuf_mmap_mapper(&fh->vb_vidq, vma);
return ret; return ret;
} }
@ -1452,8 +1452,9 @@ static struct video_device tm6000_template = {
}; };
/* ----------------------------------------------------------------- /* -----------------------------------------------------------------
Initialization and module stuff * Initialization and module stuff
------------------------------------------------------------------*/ * ------------------------------------------------------------------
*/
int tm6000_v4l2_register(struct tm6000_core *dev) int tm6000_v4l2_register(struct tm6000_core *dev)
{ {
@ -1495,11 +1496,11 @@ int tm6000_v4l2_exit(void)
} }
module_param(video_nr, int, 0); module_param(video_nr, int, 0);
MODULE_PARM_DESC(video_nr,"Allow changing video device number"); MODULE_PARM_DESC(video_nr, "Allow changing video device number");
module_param_named (debug, tm6000_debug, int, 0444); module_param_named(debug, tm6000_debug, int, 0444);
MODULE_PARM_DESC(debug,"activates debug info"); MODULE_PARM_DESC(debug, "activates debug info");
module_param(vid_limit,int,0644); module_param(vid_limit, int, 0644);
MODULE_PARM_DESC(vid_limit,"capture memory limit in megabytes"); MODULE_PARM_DESC(vid_limit, "capture memory limit in megabytes");