microsoft
/
WSL2-Linux-Kernel
зеркало из https://github.com/microsoft/WSL2-Linux-Kernel.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

V4L/DVB (11998): se401: Fix coding style 

Having fixed the sprintfs I decided a quick clean wouldn't do any harm so
it was actually easy to read in future.

Signed-off-by: Alan Cox <alan@linux.intel.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
This commit is contained in:
Alan Cox 2009-06-09 10:02:11 -03:00 коммит произвёл Mauro Carvalho Chehab
Родитель 226a040e6a
Коммит aae40fd219
2 изменённых файлов: 451 добавлений и 430 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

222
drivers/media/video/se401.c
Просмотреть файл

@ -53,7 +53,8 @@ MODULE_AUTHOR("Jeroen Vreeken <pe1rxq@amsat.org>");
MODULE_DESCRIPTION("SE401 USB Camera Driver");
MODULE_LICENSE("GPL");
module_param(flickerless, int, 0);
MODULE_PARM_DESC(flickerless, "Net frequency to adjust exposure time to (0/50/60)");
MODULE_PARM_DESC(flickerless,
"Net frequency to adjust exposure time to (0/50/60)");
module_param(video_nr, int, 0);
static struct usb_driver se401_driver;
@ -175,13 +176,20 @@ static unsigned short se401_get_feature(struct usb_se401 *se401,
static int se401_send_pict(struct usb_se401 *se401)
{
se401_set_feature(se401, HV7131_REG_TITL, se401->expose_l);/* integration time low */
se401_set_feature(se401, HV7131_REG_TITM, se401->expose_m);/* integration time mid */
se401_set_feature(se401, HV7131_REG_TITU, se401->expose_h);/* integration time mid */
se401_set_feature(se401, HV7131_REG_ARLV, se401->resetlevel);/* reset level value */
se401_set_feature(se401, HV7131_REG_ARCG, se401->rgain);/* red color gain */
se401_set_feature(se401, HV7131_REG_AGCG, se401->ggain);/* green color gain */
se401_set_feature(se401, HV7131_REG_ABCG, se401->bgain);/* blue color gain */
/* integration time low */
se401_set_feature(se401, HV7131_REG_TITL, se401->expose_l);
/* integration time mid */
se401_set_feature(se401, HV7131_REG_TITM, se401->expose_m);
/* integration time mid */
se401_set_feature(se401, HV7131_REG_TITU, se401->expose_h);
/* reset level value */
se401_set_feature(se401, HV7131_REG_ARLV, se401->resetlevel);
/* red color gain */
se401_set_feature(se401, HV7131_REG_ARCG, se401->rgain);
/* green color gain */
se401_set_feature(se401, HV7131_REG_AGCG, se401->ggain);
/* blue color gain */
se401_set_feature(se401, HV7131_REG_ABCG, se401->bgain);
return 0;
}
@ -190,12 +198,10 @@ static void se401_set_exposure(struct usb_se401 *se401, int brightness)
{
int integration = brightness << 5;
if (flickerless==50) {
if (flickerless == 50)
integration = integration-integration % 106667;
}
if (flickerless==60) {
if (flickerless == 60)
integration = integration-integration % 88889;
}
se401->brightness = integration >> 5;
se401->expose_h = (integration >> 16) & 0xff;
se401->expose_m = (integration >> 8) & 0xff;
@ -205,11 +211,11 @@ static void se401_set_exposure(struct usb_se401 *se401, int brightness)
static int se401_get_pict(struct usb_se401 *se401, struct video_picture *p)
{
p->brightness = se401->brightness;
if (se401->enhance) {
if (se401->enhance)
p->whiteness = 32768;
} else {
else
p->whiteness = 0;
}
p->colour = 65535;
p->contrast = 65535;
p->hue = se401->rgain << 10;
@ -229,14 +235,13 @@ static int se401_set_pict(struct usb_se401 *se401, struct video_picture *p)
se401->bgain = 0x40-(p->hue >> 10);
se401->hue = p->hue;
}
if (p->brightness!=se401->brightness) {
if (p->brightness != se401->brightness)
se401_set_exposure(se401, p->brightness);
}
if (p->whiteness>=32768) {
if (p->whiteness >= 32768)
se401->enhance = 1;
} else {
else
se401->enhance = 0;
}
se401_send_pict(se401);
se401_send_pict(se401);
return 0;
@ -300,17 +305,18 @@ static void se401_button_irq(struct urb *urb)
case -ENOENT:
case -ESHUTDOWN:
/* this urb is terminated, clean up */
dbg("%s - urb shutting down with status: %d", __func__, urb->status);
dbg("%s - urb shutting down with status: %d",
__func__, urb->status);
return;
default:
dbg("%s - nonzero urb status received: %d", __func__, urb->status);
dbg("%s - nonzero urb status received: %d",
__func__, urb->status);
goto exit;
}
if (urb->actual_length >=2) {
if (urb->actual_length >= 2)
if (se401->button)
se401->buttonpressed = 1;
}
exit:
status = usb_submit_urb(urb, GFP_ATOMIC);
if (status)
@ -339,37 +345,34 @@ static void se401_video_irq(struct urb *urb)
se401->nullpackets = 0;
switch (se401->scratch[se401->scratch_next].state) {
case BUFFER_READY:
case BUFFER_BUSY: {
case BUFFER_BUSY:
se401->dropped++;
break;
}
case BUFFER_UNUSED: {
memcpy(se401->scratch[se401->scratch_next].data, (unsigned char *)urb->transfer_buffer, length);
se401->scratch[se401->scratch_next].state=BUFFER_READY;
se401->scratch[se401->scratch_next].offset=se401->bayeroffset;
case BUFFER_UNUSED:
memcpy(se401->scratch[se401->scratch_next].data,
(unsigned char *)urb->transfer_buffer, length);
se401->scratch[se401->scratch_next].state
= BUFFER_READY;
se401->scratch[se401->scratch_next].offset
= se401->bayeroffset;
se401->scratch[se401->scratch_next].length = length;
if (waitqueue_active(&se401->wq)) {
if (waitqueue_active(&se401->wq))
wake_up_interruptible(&se401->wq);
}
se401->scratch_overflow = 0;
se401->scratch_next++;
if (se401->scratch_next >= SE401_NUMSCRATCH)
se401->scratch_next = 0;
break;
}
}
se401->bayeroffset += length;
if (se401->bayeroffset>=se401->cheight*se401->cwidth) {
if (se401->bayeroffset >= se401->cheight * se401->cwidth)
se401->bayeroffset = 0;
}
} else {
se401->nullpackets++;
if (se401->nullpackets > SE401_MAX_NULLPACKETS) {
if (waitqueue_active(&se401->wq)) {
if (se401->nullpackets > SE401_MAX_NULLPACKETS)
if (waitqueue_active(&se401->wq))
wake_up_interruptible(&se401->wq);
}
}
}
/* Resubmit urb for new data */
urb->status = 0;
@ -392,15 +395,18 @@ static void se401_send_size(struct usb_se401 *se401, int width, int height)
4 or 16 times subcapturing, if not we use uncompressed bayer data
but this will result in cutouts of the maximum size....
*/
while (i<se401->sizes && !(se401->width[i]==width && se401->height[i]==height))
while (i < se401->sizes && !(se401->width[i] == width &&
se401->height[i] == height))
i++;
while (i < se401->sizes) {
if (se401->width[i]==width*2 && se401->height[i]==height*2) {
if (se401->width[i] == width * 2 &&
se401->height[i] == height * 2) {
sendheight = se401->height[i];
sendwidth = se401->width[i];
mode = 0x40;
}
if (se401->width[i]==width*4 && se401->height[i]==height*4) {
if (se401->width[i] == width * 4 &&
se401->height[i] == height * 4) {
sendheight = se401->height[i];
sendwidth = se401->width[i];
mode = 0x42;
@ -412,15 +418,12 @@ static void se401_send_size(struct usb_se401 *se401, int width, int height)
se401_sndctrl(1, se401, SE401_REQ_SET_HEIGHT, sendheight, NULL, 0);
se401_set_feature(se401, SE401_OPERATINGMODE, mode);
if (mode==0x03) {
if (mode == 0x03)
se401->format = FMT_BAYER;
} else {
else
se401->format = FMT_JANGGU;
}
return;
}
/*
In this function se401_send_pict is called several times,
for some reason (depending on the state of the sensor and the phase of
@ -436,12 +439,14 @@ static int se401_start_stream(struct usb_se401 *se401)
se401_sndctrl(1, se401, SE401_REQ_LED_CONTROL, 1, NULL, 0);
/* Set picture settings */
se401_set_feature(se401, HV7131_REG_MODE_B, 0x05);/*windowed + pix intg */
/* windowed + pix intg */
se401_set_feature(se401, HV7131_REG_MODE_B, 0x05);
se401_send_pict(se401);
se401_send_size(se401, se401->cwidth, se401->cheight);
se401_sndctrl(1, se401, SE401_REQ_START_CONTINUOUS_CAPTURE, 0, NULL, 0);
se401_sndctrl(1, se401, SE401_REQ_START_CONTINUOUS_CAPTURE,
0, NULL, 0);
/* Do some memory allocation */
for (i = 0; i < SE401_NUMFRAMES; i++) {
@ -530,7 +535,8 @@ static int se401_stop_stream(struct usb_se401 *se401)
se401_sndctrl(1, se401, SE401_REQ_LED_CONTROL, 0, NULL, 0);
se401_sndctrl(1, se401, SE401_REQ_CAMERA_POWER, 0, NULL, 0);
for (i=0; i<SE401_NUMSBUF; i++) if (se401->urb[i]) {
for (i = 0; i < SE401_NUMSBUF; i++)
if (se401->urb[i]) {
usb_kill_urb(se401->urb[i]);
usb_free_urb(se401->urb[i]);
se401->urb[i] = NULL;
@ -604,16 +610,16 @@ static inline void decode_JangGu_integrate(struct usb_se401 *se401, int data)
/* First three are absolute, all others relative.
* Format is rgb from right to left (mirrorred image),
* we flip it to get bgr from left to right. */
if (frame->curlinepix < 3) {
if (frame->curlinepix < 3)
*(frame->curline-frame->curlinepix) = 1 + data * 4;
} else {
else
*(frame->curline-frame->curlinepix) =
*(frame->curline-frame->curlinepix + 3) + data * 4;
}
frame->curlinepix++;
}
static inline void decode_JangGu_vlc (struct usb_se401 *se401, unsigned char *data, int bit_exp, int packetlength)
static inline void decode_JangGu_vlc(struct usb_se401 *se401,
unsigned char *data, int bit_exp, int packetlength)
{
int pos = 0;
int vlc_cod = 0;
@ -630,9 +636,9 @@ static inline void decode_JangGu_vlc (struct usb_se401 *se401, unsigned char *da
if (bit) {
vlc_size++;
} else {
if (!vlc_size) {
if (!vlc_size)
decode_JangGu_integrate(se401, 0);
} else {
else {
vlc_cod = 2;
vlc_data = 0;
}
@ -658,7 +664,8 @@ static inline void decode_JangGu_vlc (struct usb_se401 *se401, unsigned char *da
}
}
static inline void decode_JangGu (struct usb_se401 *se401, struct se401_scratch *buffer)
static inline void decode_JangGu(struct usb_se401 *se401,
struct se401_scratch *buffer)
{
unsigned char *data = buffer->data;
int len = buffer->length;
@ -684,7 +691,8 @@ static inline void decode_JangGu (struct usb_se401 *se401, struct se401_scratch
packetlength = 0;
if (se401->vlcdatapos >= 4) {
bit_exp = se401->vlcdata[3] + (se401->vlcdata[2] << 8);
pix_exp=se401->vlcdata[1]+((se401->vlcdata[0]&0x3f)<<8);
pix_exp = se401->vlcdata[1] +
((se401->vlcdata[0] & 0x3f) << 8);
frameinfo = se401->vlcdata[0] & 0xc0;
packetlength = ((bit_exp + 47) >> 4) << 1;
if (packetlength > 1024) {
@ -696,7 +704,8 @@ static inline void decode_JangGu (struct usb_se401 *se401, struct se401_scratch
}
}
if (packetlength && se401->vlcdatapos >= packetlength) {
decode_JangGu_vlc(se401, se401->vlcdata, bit_exp, packetlength);
decode_JangGu_vlc(se401, se401->vlcdata, bit_exp,
packetlength);
se401->frame[se401->curframe].curpix += pix_exp * 3;
datapos += size-(se401->vlcdatapos-packetlength);
se401->vlcdatapos = 0;
@ -707,29 +716,26 @@ static inline void decode_JangGu (struct usb_se401 *se401, struct se401_scratch
se401->framecount++;
se401->readcount++;
}
if (se401->frame[(se401->curframe+1)&(SE401_NUMFRAMES-1)].grabstate==FRAME_READY) {
if (se401->frame[(se401->curframe + 1) & (SE401_NUMFRAMES - 1)].grabstate == FRAME_READY)
se401->curframe = (se401->curframe + 1) & (SE401_NUMFRAMES - 1);
}
} else {
} else
se401->error++;
}
se401->frame[se401->curframe].curpix = 0;
datapos = len;
}
} else {
} else
datapos += size;
}
}
}
static inline void decode_bayer (struct usb_se401 *se401, struct se401_scratch *buffer)
static inline void decode_bayer(struct usb_se401 *se401,
struct se401_scratch *buffer)
{
unsigned char *data = buffer->data;
int len = buffer->length;
int offset = buffer->offset;
int datasize = se401->cwidth * se401->cheight;
struct se401_frame *frame = &se401->frame[se401->curframe];
unsigned char *framedata = frame->data, *curline, *nextline;
int width = se401->cwidth;
int blineoffset = 0, bline;
@ -737,9 +743,9 @@ static inline void decode_bayer (struct usb_se401 *se401, struct se401_scratch *
if (frame->curpix == 0) {
if (frame->grabstate==FRAME_READY) {
if (frame->grabstate == FRAME_READY)
frame->grabstate = FRAME_GRABBING;
}
frame->curline = framedata + linelength;
frame->curlinepix = 0;
}
@ -752,9 +758,9 @@ static inline void decode_bayer (struct usb_se401 *se401, struct se401_scratch *
}
/* Check if we have to much data */
if (frame->curpix+len > datasize) {
if (frame->curpix + len > datasize)
len = datasize-frame->curpix;
}
if (se401->cheight % 4)
blineoffset = 1;
bline = frame->curpix / se401->cwidth+blineoffset;
@ -780,8 +786,8 @@ static inline void decode_bayer (struct usb_se401 *se401, struct se401_scratch *
if (nextline >= framedata+datasize*3)
nextline = curline;
}
if ((bline&1)) {
if ((frame->curlinepix&1)) {
if (bline & 1) {
if (frame->curlinepix & 1) {
*(curline + 2) = *data;
*(curline - 1) = *data;
*(nextline + 2) = *data;
@ -795,7 +801,7 @@ static inline void decode_bayer (struct usb_se401 *se401, struct se401_scratch *
*(nextline - 2) = *data;
}
} else {
if ((frame->curlinepix&1)) {
if (frame->curlinepix & 1) {
*(curline + 1) =
(*(curline + 1) + *data) / 2;
*(curline - 2) =
@ -836,8 +842,10 @@ static inline void decode_bayer (struct usb_se401 *se401, struct se401_scratch *
frame->grabstate = FRAME_DONE;
se401->framecount++;
se401->readcount++;
if (se401->frame[(se401->curframe+1)&(SE401_NUMFRAMES-1)].grabstate==FRAME_READY) {
se401->curframe=(se401->curframe+1) & (SE401_NUMFRAMES-1);
if (se401->frame[(se401->curframe + 1) &
(SE401_NUMFRAMES - 1)].grabstate == FRAME_READY) {
se401->curframe = (se401->curframe+1) &
(SE401_NUMFRAMES-1);
}
}
}
@ -850,14 +858,12 @@ static int se401_newframe(struct usb_se401 *se401, int framenr)
while (se401->streaming &&
(se401->frame[framenr].grabstate == FRAME_READY ||
se401->frame[framenr].grabstate == FRAME_GRABBING)) {
if(!se401->frame[framenr].curpix) {
if (!se401->frame[framenr].curpix)
errors++;
}
wait_interruptible(
se401->scratch[se401->scratch_use].state != BUFFER_READY,
&se401->wq,
&wait
);
&se401->wq, &wait);
if (se401->nullpackets > SE401_MAX_NULLPACKETS) {
se401->nullpackets = 0;
dev_info(&se401->dev->dev,
@ -865,17 +871,21 @@ static int se401_newframe(struct usb_se401 *se401, int framenr)
se401_stop_stream(se401);
se401_start_stream(se401);
} else {
if (se401->scratch[se401->scratch_use].state!=BUFFER_READY) {
if (se401->scratch[se401->scratch_use].state !=
BUFFER_READY) {
se401->frame[framenr].grabstate = FRAME_ERROR;
return -EIO;
}
se401->scratch[se401->scratch_use].state = BUFFER_BUSY;
if (se401->format==FMT_JANGGU) {
decode_JangGu(se401, &se401->scratch[se401->scratch_use]);
} else {
decode_bayer(se401, &se401->scratch[se401->scratch_use]);
}
se401->scratch[se401->scratch_use].state=BUFFER_UNUSED;
if (se401->format == FMT_JANGGU)
decode_JangGu(se401,
&se401->scratch[se401->scratch_use]);
else
decode_bayer(se401,
&se401->scratch[se401->scratch_use]);
se401->scratch[se401->scratch_use].state =
BUFFER_UNUSED;
se401->scratch_use++;
if (se401->scratch_use >= SE401_NUMSCRATCH)
se401->scratch_use = 0;
@ -891,7 +901,8 @@ static int se401_newframe(struct usb_se401 *se401, int framenr)
if (se401->frame[framenr].grabstate == FRAME_DONE)
if (se401->enhance)
enhance_picture(se401->frame[framenr].data, se401->cheight*se401->cwidth*3);
enhance_picture(se401->frame[framenr].data,
se401->cheight * se401->cwidth * 3);
return 0;
}
@ -908,9 +919,10 @@ static void usb_se401_remove_disconnected (struct usb_se401 *se401)
se401->urb[i] = NULL;
kfree(se401->sbuf[i].data);
}
for (i=0; i<SE401_NUMSCRATCH; i++) {
for (i = 0; i < SE401_NUMSCRATCH; i++)
kfree(se401->scratch[i].data);
}
if (se401->inturb) {
usb_kill_urb(se401->inturb);
usb_free_urb(se401->inturb);
@ -1199,7 +1211,8 @@ static int se401_mmap(struct file *file, struct vm_area_struct *vma)
mutex_unlock(&se401->lock);
return -EIO;
}
if (size > (((SE401_NUMFRAMES * se401->maxframesize) + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1))) {
if (size > (((SE401_NUMFRAMES * se401->maxframesize) + PAGE_SIZE - 1)
& ~(PAGE_SIZE - 1))) {
mutex_unlock(&se401->lock);
return -EINVAL;
}
@ -1250,7 +1263,8 @@ static int se401_init(struct usb_se401 *se401, int button)
se401_sndctrl(1, se401, SE401_REQ_LED_CONTROL, 1, NULL, 0);
/* get camera descriptor */
rc=se401_sndctrl(0, se401, SE401_REQ_GET_CAMERA_DESCRIPTOR, 0, cp, sizeof(cp));
rc = se401_sndctrl(0, se401, SE401_REQ_GET_CAMERA_DESCRIPTOR, 0,
cp, sizeof(cp));
if (cp[1] != 0x41) {
err("Wrong descriptor type");
return 1;
@ -1276,7 +1290,8 @@ static int se401_init(struct usb_se401 *se401, int button)
" %dx%d", se401->width[i], se401->height[i]);
}
dev_info(&se401->dev->dev, "%s\n", temp);
se401->maxframesize=se401->width[se401->sizes-1]*se401->height[se401->sizes-1]*3;
se401->maxframesize = se401->width[se401->sizes-1] *
se401->height[se401->sizes - 1] * 3;
rc = se401_sndctrl(0, se401, SE401_REQ_GET_WIDTH, 0, cp, sizeof(cp));
se401->cwidth = cp[0]+cp[1]*256;
@ -1288,7 +1303,8 @@ static int se401_init(struct usb_se401 *se401, int button)
return 1;
}
/* set output mode (BAYER) */
se401_sndctrl(1, se401, SE401_REQ_SET_OUTPUT_MODE, SE401_FORMAT_BAYER, NULL, 0);
se401_sndctrl(1, se401, SE401_REQ_SET_OUTPUT_MODE,
SE401_FORMAT_BAYER, NULL, 0);
rc = se401_sndctrl(0, se401, SE401_REQ_GET_BRT, 0, cp, sizeof(cp));
se401->brightness = cp[0]+cp[1]*256;
@ -1380,7 +1396,8 @@ static int se401_probe(struct usb_interface *intf,
/* We found one */
dev_info(&intf->dev, "SE401 camera found: %s\n", camera_name);
if ((se401 = kzalloc(sizeof(*se401), GFP_KERNEL)) == NULL) {
se401 = kzalloc(sizeof(*se401), GFP_KERNEL);
if (se401 == NULL) {
err("couldn't kmalloc se401 struct");
return -ENOMEM;
}
@ -1398,12 +1415,14 @@ static int se401_probe(struct usb_interface *intf,
}
memcpy(&se401->vdev, &se401_template, sizeof(se401_template));
memcpy(se401->vdev.name, se401->camera_name, strlen(se401->camera_name));
memcpy(se401->vdev.name, se401->camera_name,
strlen(se401->camera_name));
init_waitqueue_head(&se401->wq);
mutex_init(&se401->lock);
wmb();
if (video_register_device(&se401->vdev, VFL_TYPE_GRABBER, video_nr) < 0) {
if (video_register_device(&se401->vdev,
VFL_TYPE_GRABBER, video_nr) < 0) {
kfree(se401);
err("video_register_device failed");
return -EIO;
@ -1422,9 +1441,9 @@ static void se401_disconnect(struct usb_interface *intf)
usb_set_intfdata(intf, NULL);
if (se401) {
video_unregister_device(&se401->vdev);
if (!se401->user){
if (!se401->user)
usb_se401_remove_disconnected(se401);
} else {
else {
se401->frame[0].grabstate = FRAME_ERROR;
se401->frame[0].grabstate = FRAME_ERROR;
@ -1453,7 +1472,8 @@ static struct usb_driver se401_driver = {
static int __init usb_se401_init(void)
{
printk(KERN_INFO "SE401 usb camera driver version %s registering\n", version);
printk(KERN_INFO "SE401 usb camera driver version %s registering\n",
version);
if (flickerless)
if (flickerless != 50 && flickerless != 60) {
printk(KERN_ERR "Invallid flickerless value, use 0, 50 or 60.\n");

5
drivers/media/video/se401.h
Просмотреть файл

@ -2,7 +2,7 @@
#ifndef __LINUX_se401_H
#define __LINUX_se401_H
#include <asm/uaccess.h>
#include <linux/uaccess.h>
#include <linux/videodev.h>
#include <media/v4l2-common.h>
#include <media/v4l2-ioctl.h>
@ -12,7 +12,8 @@
#ifdef se401_DEBUG
# define PDEBUG(level, fmt, args...) \
if (debug >= level) info("[" __PRETTY_FUNCTION__ ":%d] " fmt, __LINE__ , ## args)
if (debug >= level) \
info("[" __PRETTY_FUNCTION__ ":%d] " fmt, __LINE__ , ## args)
#else
# define PDEBUG(level, fmt, args...) do {} while (0)
#endif