leandrof/linux
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

Browse Source 
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 committed by Mauro Carvalho Chehab
parent 226a040e6a
commit aae40fd219
2 changed files with 451 additions and 430 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

222
drivers/media/video/se401.c
View File

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

5
drivers/media/video/se401.h
View File

@ -2,7 +2,7 @@
#ifndef __LINUX_se401_H #ifndef __LINUX_se401_H
#define __LINUX_se401_H #define __LINUX_se401_H
#include <asm/uaccess.h> #include <linux/uaccess.h>
#include <linux/videodev.h> #include <linux/videodev.h>
#include <media/v4l2-common.h> #include <media/v4l2-common.h>
#include <media/v4l2-ioctl.h> #include <media/v4l2-ioctl.h>
@ -12,7 +12,8 @@
#ifdef se401_DEBUG #ifdef se401_DEBUG
# define PDEBUG(level, fmt, args...) \ # 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 #else
# define PDEBUG(level, fmt, args...) do {} while (0) # define PDEBUG(level, fmt, args...) do {} while (0)
#endif #endif