OpenE2K
/
linux
6
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

V4L/DVB (8752): s2255drv: firmware improvement patch 

Fix for reloading firmware when removing and reloading driver
Handshaking for firmware loading and changing modes.
Removes the restriction of one user per channel at a time.
JPEG capture mode added.

Signed-off-by: Dean Anderson <dean@sensoray.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
This commit is contained in:
Dean Anderson 2008-08-25 13:58:55 -03:00 committed by Mauro Carvalho Chehab
parent ee7aa9f821
commit 14d962602c
1 changed files with 306 additions and 247 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

553
drivers/media/video/s2255drv.c
View File

@ -67,20 +67,21 @@
/* USB endpoint number for configuring the device */
#define S2255_CONFIG_EP 2
/* maximum time for DSP to start responding after last FW word loaded(ms) */
#define S2255_DSP_BOOTTIME 400
#define S2255_DSP_BOOTTIME 800
/* maximum time to wait for firmware to load (ms) */
#define S2255_LOAD_TIMEOUT (5000 + S2255_DSP_BOOTTIME)
#define S2255_DEF_BUFS 16
#define S2255_SETMODE_TIMEOUT 500
#define MAX_CHANNELS 4
#define FRAME_MARKER 0x2255DA4AL
#define MAX_PIPE_USBBLOCK (40 * 1024)
#define DEFAULT_PIPE_USBBLOCK (16 * 1024)
#define S2255_MARKER_FRAME 0x2255DA4AL
#define S2255_MARKER_RESPONSE 0x2255ACACL
#define S2255_USB_XFER_SIZE (16 * 1024)
#define MAX_CHANNELS 4
#define MAX_PIPE_BUFFERS 1
#define SYS_FRAMES 4
/* maximum size is PAL full size plus room for the marker header(s) */
#define SYS_FRAMES_MAXSIZE (720 * 288 * 2 * 2 + 4096)
#define DEF_USB_BLOCK (4096)
#define SYS_FRAMES_MAXSIZE (720*288*2*2 + 4096)
#define DEF_USB_BLOCK S2255_USB_XFER_SIZE
#define LINE_SZ_4CIFS_NTSC 640
#define LINE_SZ_2CIFS_NTSC 640
#define LINE_SZ_1CIFS_NTSC 320
@ -108,6 +109,9 @@
#define COLOR_YUVPL 1 /* YUV planar */
#define COLOR_YUVPK 2 /* YUV packed */
#define COLOR_Y8 4 /* monochrome */
#define COLOR_JPG 5 /* JPEG */
#define MASK_COLOR 0xff
#define MASK_JPG_QUALITY 0xff00
/* frame decimation. Not implemented by V4L yet(experimental in V4L) */
#define FDEC_1 1 /* capture every frame. default */
@ -148,16 +152,14 @@ struct s2255_mode {
u32 restart; /* if DSP requires restart */
};
#define S2255_READ_IDLE 0
#define S2255_READ_FRAME 1
/* frame structure */
#define FRAME_STATE_UNUSED 0
#define FRAME_STATE_FILLING 1
#define FRAME_STATE_FULL 2
struct s2255_framei {
unsigned long size;
unsigned long ulState; /* ulState ==0 unused, 1 being filled, 2 full */
unsigned long ulState; /* ulState:S2255_READ_IDLE, S2255_READ_FRAME*/
void *lpvbits; /* image data */
unsigned long cur_size; /* current data copied to it */
};
@ -188,6 +190,10 @@ struct s2255_dmaqueue {
#define S2255_FW_FAILED 3
#define S2255_FW_DISCONNECTING 4
#define S2255_FW_MARKER 0x22552f2f
/* 2255 read states */
#define S2255_READ_IDLE 0
#define S2255_READ_FRAME 1
struct s2255_fw {
int fw_loaded;
int fw_size;
@ -195,7 +201,6 @@ struct s2255_fw {
atomic_t fw_state;
void *pfw_data;
wait_queue_head_t wait_fw;
struct timer_list dsp_wait;
const struct firmware *fw;
};
@ -242,10 +247,20 @@ struct s2255_dev {
int last_frame[MAX_CHANNELS];
u32 cc; /* current channel */
int b_acquire[MAX_CHANNELS];
/* allocated image size */
unsigned long req_image_size[MAX_CHANNELS];
/* received packet size */
unsigned long pkt_size[MAX_CHANNELS];
int bad_payload[MAX_CHANNELS];
unsigned long frame_count[MAX_CHANNELS];
int frame_ready;
/* if JPEG image */
int jpg_size[MAX_CHANNELS];
/* if channel configured to default state */
int chn_configured[MAX_CHANNELS];
wait_queue_head_t wait_setmode[MAX_CHANNELS];
int setmode_ready[MAX_CHANNELS];
int chn_ready;
struct kref kref;
spinlock_t slock;
};
@ -306,12 +321,16 @@ static void s2255_stop_readpipe(struct s2255_dev *dev);
static int s2255_start_acquire(struct s2255_dev *dev, unsigned long chn);
static int s2255_stop_acquire(struct s2255_dev *dev, unsigned long chn);
static void s2255_fillbuff(struct s2255_dev *dev, struct s2255_buffer *buf,
int chn);
int chn, int jpgsize);
static int s2255_set_mode(struct s2255_dev *dev, unsigned long chn,
struct s2255_mode *mode);
static int s2255_board_shutdown(struct s2255_dev *dev);
static void s2255_exit_v4l(struct s2255_dev *dev);
static void s2255_fwload_start(struct s2255_dev *dev);
static void s2255_fwload_start(struct s2255_dev *dev, int reset);
static void s2255_destroy(struct kref *kref);
static long s2255_vendor_req(struct s2255_dev *dev, unsigned char req,
u16 index, u16 value, void *buf,
s32 buf_len, int bOut);
#define dprintk(level, fmt, arg...) \
do { \
@ -406,6 +425,10 @@ static const struct s2255_fmt formats[] = {
.name = "4:2:2, packed, UYVY",
.fourcc = V4L2_PIX_FMT_UYVY,
.depth = 16
}, {
.name = "JPG",
.fourcc = V4L2_PIX_FMT_JPEG,
.depth = 24
}, {
.name = "8bpp GREY",
.fourcc = V4L2_PIX_FMT_GREY,
@ -464,6 +487,13 @@ static void planar422p_to_yuv_packed(const unsigned char *in,
return;
}
void s2255_reset_dsppower(struct s2255_dev *dev)
{
s2255_vendor_req(dev, 0x40, 0x0b0b, 0x0b0b, NULL, 0, 1);
msleep(10);
s2255_vendor_req(dev, 0x50, 0x0000, 0x0000, NULL, 0, 1);
return;
}
/* kickstarts the firmware loading. from probe
*/
@ -480,18 +510,6 @@ static void s2255_timer(unsigned long user_data)
}
}
/* called when DSP is up and running. DSP is guaranteed to
be running after S2255_DSP_BOOTTIME */
static void s2255_dsp_running(unsigned long user_data)
{
struct s2255_fw *data = (struct s2255_fw *)user_data;
dprintk(1, "dsp running\n");
atomic_set(&data->fw_state, S2255_FW_SUCCESS);
wake_up(&data->wait_fw);
printk(KERN_INFO "s2255: firmware loaded successfully\n");
return;
}
/* this loads the firmware asynchronously.
Originally this was done synchroously in probe.
@ -549,19 +567,14 @@ static void s2255_fwchunk_complete(struct urb *urb)
}
data->fw_loaded += len;
} else {
init_timer(&data->dsp_wait);
data->dsp_wait.function = s2255_dsp_running;
data->dsp_wait.data = (unsigned long)data;
atomic_set(&data->fw_state, S2255_FW_LOADED_DSPWAIT);
mod_timer(&data->dsp_wait, msecs_to_jiffies(S2255_DSP_BOOTTIME)
+ jiffies);
}
dprintk(100, "2255 complete done\n");
return;
}
static int s2255_got_frame(struct s2255_dev *dev, int chn)
static int s2255_got_frame(struct s2255_dev *dev, int chn, int jpgsize)
{
struct s2255_dmaqueue *dma_q = &dev->vidq[chn];
struct s2255_buffer *buf;
@ -586,8 +599,7 @@ static int s2255_got_frame(struct s2255_dev *dev, int chn)
list_del(&buf->vb.queue);
do_gettimeofday(&buf->vb.ts);
dprintk(100, "[%p/%d] wakeup\n", buf, buf->vb.i);
s2255_fillbuff(dev, buf, dma_q->channel);
s2255_fillbuff(dev, buf, dma_q->channel, jpgsize);
wake_up(&buf->vb.done);
dprintk(2, "wakeup [buf/i] [%p/%d]\n", buf, buf->vb.i);
unlock:
@ -621,7 +633,7 @@ static const struct s2255_fmt *format_by_fourcc(int fourcc)
*
*/
static void s2255_fillbuff(struct s2255_dev *dev, struct s2255_buffer *buf,
int chn)
int chn, int jpgsize)
{
int pos = 0;
struct timeval ts;
@ -649,6 +661,10 @@ static void s2255_fillbuff(struct s2255_dev *dev, struct s2255_buffer *buf,
case V4L2_PIX_FMT_GREY:
memcpy(vbuf, tmpbuf, buf->vb.width * buf->vb.height);
break;
case V4L2_PIX_FMT_JPEG:
buf->vb.size = jpgsize;
memcpy(vbuf, tmpbuf, buf->vb.size);
break;
case V4L2_PIX_FMT_YUV422P:
memcpy(vbuf, tmpbuf,
buf->vb.width * buf->vb.height * 2);
@ -657,9 +673,6 @@ static void s2255_fillbuff(struct s2255_dev *dev, struct s2255_buffer *buf,
printk(KERN_DEBUG "s2255: unknown format?\n");
}
dev->last_frame[chn] = -1;
/* done with the frame, free it */
frm->ulState = 0;
dprintk(4, "freeing buffer\n");
} else {
printk(KERN_ERR "s2255: =======no frame\n");
return;
@ -1021,6 +1034,9 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
case V4L2_PIX_FMT_GREY:
fh->mode.color = COLOR_Y8;
break;
case V4L2_PIX_FMT_JPEG:
fh->mode.color = COLOR_JPG | (50 << 8);
break;
case V4L2_PIX_FMT_YUV422P:
fh->mode.color = COLOR_YUVPL;
break;
@ -1139,7 +1155,7 @@ static u32 get_transfer_size(struct s2255_mode *mode)
}
}
outImageSize = linesPerFrame * pixelsPerLine;
if (mode->color != COLOR_Y8) {
if ((mode->color & MASK_COLOR) != COLOR_Y8) {
/* 2 bytes/pixel if not monochrome */
outImageSize *= 2;
}
@ -1185,6 +1201,7 @@ static int s2255_set_mode(struct s2255_dev *dev, unsigned long chn,
u32 *buffer;
unsigned long chn_rev;
mutex_lock(&dev->lock);
chn_rev = G_chnmap[chn];
dprintk(3, "mode scale [%ld] %p %d\n", chn, mode, mode->scale);
dprintk(3, "mode scale [%ld] %p %d\n", chn, &dev->mode[chn],
@ -1199,6 +1216,7 @@ static int s2255_set_mode(struct s2255_dev *dev, unsigned long chn,
buffer = kzalloc(512, GFP_KERNEL);
if (buffer == NULL) {
dev_err(&dev->udev->dev, "out of mem\n");
mutex_unlock(&dev->lock);
return -ENOMEM;
}
@ -1214,12 +1232,20 @@ static int s2255_set_mode(struct s2255_dev *dev, unsigned long chn,
dprintk(1, "set mode done chn %lu, %d\n", chn, res);
/* wait at least 3 frames before continuing */
if (mode->restart)
msleep(125);
if (mode->restart) {
dev->setmode_ready[chn] = 0;
wait_event_timeout(dev->wait_setmode[chn],
(dev->setmode_ready[chn] != 0),
msecs_to_jiffies(S2255_SETMODE_TIMEOUT));
if (dev->setmode_ready[chn] != 1) {
printk(KERN_DEBUG "s2255: no set mode response\n");
res = -EFAULT;
}
}
/* clear the restart flag */
dev->mode[chn].restart = 0;
mutex_unlock(&dev->lock);
return res;
}
@ -1270,7 +1296,7 @@ static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
dev->cur_frame[chn] = 0;
dev->frame_count[chn] = 0;
for (j = 0; j < SYS_FRAMES; j++) {
dev->buffer[chn].frame[j].ulState = 0;
dev->buffer[chn].frame[j].ulState = S2255_READ_IDLE;
dev->buffer[chn].frame[j].cur_size = 0;
}
res = videobuf_streamon(&fh->vb_vidq);
@ -1455,6 +1481,7 @@ static int s2255_open(struct inode *inode, struct file *file)
enum v4l2_buf_type type = 0;
int i = 0;
int cur_channel = -1;
int state;
dprintk(1, "s2255: open called (minor=%d)\n", minor);
lock_kernel();
@ -1471,47 +1498,77 @@ static int s2255_open(struct inode *inode, struct file *file)
if ((NULL == dev) || (cur_channel == -1)) {
unlock_kernel();
dprintk(1, "s2255: openv4l no dev\n");
printk(KERN_INFO "s2255: openv4l no dev\n");
return -ENODEV;
}
if (atomic_read(&dev->fw_data->fw_state) == S2255_FW_DISCONNECTING) {
unlock_kernel();
printk(KERN_INFO "disconnecting\n");
return -ENODEV;
}
kref_get(&dev->kref);
mutex_lock(&dev->open_lock);
dev->users[cur_channel]++;
dprintk(4, "s2255: open_handles %d\n", dev->users[cur_channel]);
if (atomic_read(&dev->fw_data->fw_state) == S2255_FW_FAILED) {
switch (atomic_read(&dev->fw_data->fw_state)) {
case S2255_FW_FAILED:
err("2255 firmware load failed. retrying.\n");
s2255_fwload_start(dev);
s2255_fwload_start(dev, 1);
wait_event_timeout(dev->fw_data->wait_fw,
(atomic_read(&dev->fw_data->fw_state)
!= S2255_FW_NOTLOADED),
((atomic_read(&dev->fw_data->fw_state)
== S2255_FW_SUCCESS) ||
(atomic_read(&dev->fw_data->fw_state)
== S2255_FW_DISCONNECTING)),
msecs_to_jiffies(S2255_LOAD_TIMEOUT));
if (atomic_read(&dev->fw_data->fw_state)
!= S2255_FW_SUCCESS) {
printk(KERN_INFO "2255 FW load failed.\n");
dev->users[cur_channel]--;
mutex_unlock(&dev->open_lock);
unlock_kernel();
return -EFAULT;
}
} else if (atomic_read(&dev->fw_data->fw_state) == S2255_FW_NOTLOADED) {
break;
case S2255_FW_NOTLOADED:
case S2255_FW_LOADED_DSPWAIT:
/* give S2255_LOAD_TIMEOUT time for firmware to load in case
driver loaded and then device immediately opened */
printk(KERN_INFO "%s waiting for firmware load\n", __func__);
wait_event_timeout(dev->fw_data->wait_fw,
(atomic_read(&dev->fw_data->fw_state)
!= S2255_FW_NOTLOADED),
msecs_to_jiffies(S2255_LOAD_TIMEOUT));
if (atomic_read(&dev->fw_data->fw_state)
!= S2255_FW_SUCCESS) {
printk(KERN_INFO "2255 firmware not loaded"
"try again\n");
dev->users[cur_channel]--;
mutex_unlock(&dev->open_lock);
unlock_kernel();
return -EBUSY;
((atomic_read(&dev->fw_data->fw_state)
== S2255_FW_SUCCESS) ||
(atomic_read(&dev->fw_data->fw_state)
== S2255_FW_DISCONNECTING)),
msecs_to_jiffies(S2255_LOAD_TIMEOUT));
break;
case S2255_FW_SUCCESS:
default:
break;
}
state = atomic_read(&dev->fw_data->fw_state);
if (state != S2255_FW_SUCCESS) {
int rc;
switch (state) {
case S2255_FW_FAILED:
printk(KERN_INFO "2255 FW load failed. %d\n", state);
rc = -ENODEV;
break;
case S2255_FW_DISCONNECTING:
printk(KERN_INFO "%s: disconnecting\n", __func__);
rc = -ENODEV;
break;
case S2255_FW_LOADED_DSPWAIT:
case S2255_FW_NOTLOADED:
printk(KERN_INFO "%s: firmware not loaded yet"
"please try again later\n",
__func__);
rc = -EAGAIN;
break;
default:
printk(KERN_INFO "%s: unknown state\n", __func__);
rc = -EFAULT;
break;
}
dev->users[cur_channel]--;
mutex_unlock(&dev->open_lock);
kref_put(&dev->kref, s2255_destroy);
unlock_kernel();
return rc;
}
/* allocate + initialize per filehandle data */
@ -1519,6 +1576,7 @@ static int s2255_open(struct inode *inode, struct file *file)
if (NULL == fh) {
dev->users[cur_channel]--;
mutex_unlock(&dev->open_lock);
kref_put(&dev->kref, s2255_destroy);
unlock_kernel();
return -ENOMEM;
}
@ -1533,6 +1591,13 @@ static int s2255_open(struct inode *inode, struct file *file)
fh->height = NUM_LINES_4CIFS_NTSC * 2;
fh->channel = cur_channel;
/* configure channel to default state */
if (!dev->chn_configured[cur_channel]) {
s2255_set_mode(dev, cur_channel, &fh->mode);
dev->chn_configured[cur_channel] = 1;
}
/* Put all controls at a sane state */
for (i = 0; i < ARRAY_SIZE(s2255_qctrl); i++)
qctl_regs[i] = s2255_qctrl[i].default_value;
@ -1551,7 +1616,6 @@ static int s2255_open(struct inode *inode, struct file *file)
V4L2_FIELD_INTERLACED,
sizeof(struct s2255_buffer), fh);
kref_get(&dev->kref);
mutex_unlock(&dev->open_lock);
unlock_kernel();
return 0;
@ -1575,30 +1639,24 @@ static unsigned int s2255_poll(struct file *file,
static void s2255_destroy(struct kref *kref)
{
struct s2255_dev *dev = to_s2255_dev(kref);
struct list_head *list;
int i;
if (!dev) {
printk(KERN_ERR "s2255drv: kref problem\n");
return;
}
/*
* Wake up any firmware load waiting (only done in .open,
* which holds the open_lock mutex)
*/
atomic_set(&dev->fw_data->fw_state, S2255_FW_DISCONNECTING);
wake_up(&dev->fw_data->wait_fw);
/* prevent s2255_disconnect from racing s2255_open */
for (i = 0; i < MAX_CHANNELS; i++) {
dev->setmode_ready[i] = 1;
wake_up(&dev->wait_setmode[i]);
}
mutex_lock(&dev->open_lock);
/* reset the DSP so firmware can be reload next time */
s2255_reset_dsppower(dev);
s2255_exit_v4l(dev);
/*
* device unregistered so no longer possible to open. open_mutex
* can be unlocked and timers deleted afterwards.
*/
mutex_unlock(&dev->open_lock);
/* board shutdown stops the read pipe if it is running */
s2255_board_shutdown(dev);
/* make sure firmware still not trying to load */
del_timer(&dev->timer); /* only started in .probe and .open */
@ -1608,23 +1666,19 @@ static void s2255_destroy(struct kref *kref)
usb_free_urb(dev->fw_data->fw_urb);
dev->fw_data->fw_urb = NULL;
}
/*
* delete the dsp_wait timer, which sets the firmware
* state on completion. This is done before fw_data
* is freed below.
*/
del_timer(&dev->fw_data->dsp_wait); /* only started in .open */
if (dev->fw_data->fw)
release_firmware(dev->fw_data->fw);
kfree(dev->fw_data->pfw_data);
kfree(dev->fw_data);
usb_put_dev(dev->udev);
dprintk(1, "%s", __func__);
kfree(dev);
while (!list_empty(&s2255_devlist)) {
list = s2255_devlist.next;
list_del(list);
}
mutex_unlock(&dev->open_lock);
}
static int s2255_close(struct inode *inode, struct file *file)
@ -1760,18 +1814,16 @@ static int s2255_probe_v4l(struct s2255_dev *dev)
static void s2255_exit_v4l(struct s2255_dev *dev)
{
struct list_head *list;
int i;
/* unregister the video devices */
while (!list_empty(&s2255_devlist)) {
list = s2255_devlist.next;
list_del(list);
}
for (i = 0; i < MAX_CHANNELS; i++) {
if (-1 != dev->vdev[i]->minor)
if (-1 != dev->vdev[i]->minor) {
video_unregister_device(dev->vdev[i]);
else
printk(KERN_INFO "s2255 unregistered\n");
} else {
video_device_release(dev->vdev[i]);
printk(KERN_INFO "s2255 released\n");
}
}
}
@ -1781,133 +1833,122 @@ static void s2255_exit_v4l(struct s2255_dev *dev)
* function again).
*
* Received frame structure:
* bytes 0-3: marker : 0x2255DA4AL (FRAME_MARKER)
* bytes 0-3: marker : 0x2255DA4AL (S2255_MARKER_FRAME)
* bytes 4-7: channel: 0-3
* bytes 8-11: payload size: size of the frame
* bytes 12-payloadsize+12: frame data
*/
static int save_frame(struct s2255_dev *dev, struct s2255_pipeinfo *pipe_info)
{
static int dbgsync; /* = 0; */
char *pdest;
u32 offset = 0;
int bsync = 0;
int btrunc = 0;
int bframe = 0;
char *psrc;
unsigned long copy_size;
unsigned long size;
s32 idx = -1;
struct s2255_framei *frm;
unsigned char *pdata;
unsigned long cur_size;
int bsearch = 0;
struct s2255_bufferi *buf;
dprintk(100, "buffer to user\n");
idx = dev->cur_frame[dev->cc];
buf = &dev->buffer[dev->cc];
frm = &buf->frame[idx];
if (frm->ulState == 0) {
frm->ulState = 1;
frm->cur_size = 0;
bsearch = 1;
} else if (frm->ulState == 2) {
/* system frame was not freed */
dprintk(2, "sys frame not free. overrun ringbuf\n");
bsearch = 1;
frm->ulState = 1;
frm->cur_size = 0;
}
if (bsearch) {
if (*(s32 *) pipe_info->transfer_buffer != FRAME_MARKER) {
u32 jj;
if (dbgsync == 0) {
dprintk(3, "not synched, discarding all packets"
"until marker\n");
dbgsync++;
}
pdata = (unsigned char *)pipe_info->transfer_buffer;
for (jj = 0; jj < (pipe_info->cur_transfer_size - 12);
jj++) {
if (*(s32 *) pdata == FRAME_MARKER) {
int cc;
dprintk(3,
"found frame marker at offset:"
" %d [%x %x]\n", jj, pdata[0],
pdata[1]);
offset = jj;
bsync = 1;
cc = *(u32 *) (pdata + sizeof(u32));
if (cc >= MAX_CHANNELS) {
printk(KERN_ERR
"bad channel\n");
return -EINVAL;
}
/* reverse it */
dev->cc = G_chnmap[cc];
break;
}
pdata++;
}
if (bsync == 0)
return -EINVAL;
} else {
u32 *pword;
u32 payload;
int cc;
dbgsync = 0;
bsync = 1;
pword = (u32 *) pipe_info->transfer_buffer;
cc = pword[1];
if (cc >= MAX_CHANNELS) {
printk("invalid channel found. "
"throwing out data!\n");
return -EINVAL;
}
dev->cc = G_chnmap[cc];
payload = pword[2];
if (payload != dev->req_image_size[dev->cc]) {
dprintk(1, "[%d][%d]unexpected payload: %d"
"required: %lu \n", cc, dev->cc,
payload, dev->req_image_size[dev->cc]);
dev->bad_payload[dev->cc]++;
/* discard the bad frame */
return -EINVAL;
}
}
}
/* search done. now find out if should be acquiring
on this channel */
if (!dev->b_acquire[dev->cc]) {
frm->ulState = 0;
return -EINVAL;
}
idx = dev->cur_frame[dev->cc];
frm = &dev->buffer[dev->cc].frame[idx];
if (frm->ulState == 0) {
frm->ulState = 1;
frm->cur_size = 0;
} else if (frm->ulState == 2) {
/* system frame ring buffer overrun */
dprintk(2, "sys frame overrun. overwriting frame %d %d\n",
dev->cc, idx);
frm->ulState = 1;
if (frm->ulState == S2255_READ_IDLE) {
int jj;
unsigned int cc;
s32 *pdword;
int payload;
/* search for marker codes */
pdata = (unsigned char *)pipe_info->transfer_buffer;
for (jj = 0; jj < (pipe_info->cur_transfer_size - 12); jj++) {
switch (*(s32 *) pdata) {
case S2255_MARKER_FRAME:
pdword = (s32 *)pdata;
dprintk(4, "found frame marker at offset:"
" %d [%x %x]\n", jj, pdata[0],
pdata[1]);
offset = jj + PREFIX_SIZE;
bframe = 1;
cc = pdword[1];
if (cc >= MAX_CHANNELS) {
printk(KERN_ERR
"bad channel\n");
return -EINVAL;
}
/* reverse it */
dev->cc = G_chnmap[cc];
payload = pdword[3];
if (payload > dev->req_image_size[dev->cc]) {
dev->bad_payload[dev->cc]++;
/* discard the bad frame */
return -EINVAL;
}
dev->pkt_size[dev->cc] = payload;
dev->jpg_size[dev->cc] = pdword[4];
break;
case S2255_MARKER_RESPONSE:
pdword = (s32 *)pdata;
pdata += DEF_USB_BLOCK;
jj += DEF_USB_BLOCK;
if (pdword[1] >= MAX_CHANNELS)
break;
cc = G_chnmap[pdword[1]];
if (!(cc >= 0 && cc < MAX_CHANNELS))
break;
switch (pdword[2]) {
case 0x01:
/* check if channel valid */
/* set mode ready */
dev->setmode_ready[cc] = 1;
wake_up(&dev->wait_setmode[cc]);
dprintk(5, "setmode ready %d\n", cc);
break;
case 0x10:
dev->chn_ready |= (1 << cc);
if ((dev->chn_ready & 0x0f) != 0x0f)
break;
/* all channels ready */
printk(KERN_INFO "s2255: fw loaded\n");
atomic_set(&dev->fw_data->fw_state,
S2255_FW_SUCCESS);
wake_up(&dev->fw_data->wait_fw);
break;
default:
printk(KERN_INFO "s2255 unknwn resp\n");
}
default:
pdata++;
break;
}
if (bframe)
break;
} /* for */
if (!bframe)
return -EINVAL;
}
idx = dev->cur_frame[dev->cc];
frm = &dev->buffer[dev->cc].frame[idx];
/* search done. now find out if should be acquiring on this channel */
if (!dev->b_acquire[dev->cc]) {
/* we found a frame, but this channel is turned off */
frm->ulState = S2255_READ_IDLE;
return -EINVAL;
}
if (frm->ulState == S2255_READ_IDLE) {
frm->ulState = S2255_READ_FRAME;
frm->cur_size = 0;
}
if (bsync) {
/* skip the marker 512 bytes (and offset if out of sync) */
psrc = (u8 *)pipe_info->transfer_buffer + offset + PREFIX_SIZE;
} else {
psrc = (u8 *)pipe_info->transfer_buffer;
}
/* skip the marker 512 bytes (and offset if out of sync) */
psrc = (u8 *)pipe_info->transfer_buffer + offset;
if (frm->lpvbits == NULL) {
dprintk(1, "s2255 frame buffer == NULL.%p %p %d %d",
@ -1917,33 +1958,20 @@ static int save_frame(struct s2255_dev *dev, struct s2255_pipeinfo *pipe_info)
pdest = frm->lpvbits + frm->cur_size;
if (bsync) {
copy_size =
(pipe_info->cur_transfer_size - offset) - PREFIX_SIZE;
if (copy_size > pipe_info->cur_transfer_size) {
printk("invalid copy size, overflow!\n");
return -ENOMEM;
}
} else {
copy_size = pipe_info->cur_transfer_size;
}
copy_size = (pipe_info->cur_transfer_size - offset);
cur_size = frm->cur_size;
size = dev->req_image_size[dev->cc];
size = dev->pkt_size[dev->cc] - PREFIX_SIZE;
if ((copy_size + cur_size) > size) {
copy_size = size - cur_size;
btrunc = 1;
}
/* sanity check on pdest */
if ((copy_size + frm->cur_size) < dev->req_image_size[dev->cc])
memcpy(pdest, psrc, copy_size);
memcpy(pdest, psrc, copy_size);
cur_size += copy_size;
frm->cur_size += copy_size;
dprintk(50, "cur_size size %lu size %lu \n", cur_size, size);
dprintk(4, "cur_size size %lu size %lu \n", frm->cur_size, size);
if (frm->cur_size >= size) {
if (cur_size >= (size - PREFIX_SIZE)) {
u32 cc = dev->cc;
frm->ulState = 2;
dprintk(2, "****************[%d]Buffer[%d]full*************\n",
cc, idx);
dev->last_frame[cc] = dev->cur_frame[cc];
@ -1952,16 +1980,13 @@ static int save_frame(struct s2255_dev *dev, struct s2255_pipeinfo *pipe_info)
if ((dev->cur_frame[cc] == SYS_FRAMES) ||
(dev->cur_frame[cc] == dev->buffer[cc].dwFrames))
dev->cur_frame[cc] = 0;
/* signal the semaphore for this channel */
/* frame ready */
if (dev->b_acquire[cc])
s2255_got_frame(dev, cc);
s2255_got_frame(dev, cc, dev->jpg_size[cc]);
dev->frame_count[cc]++;
}
/* frame was truncated */
if (btrunc) {
/* return more data to process */
return EAGAIN;
frm->ulState = S2255_READ_IDLE;
frm->cur_size = 0;
}
/* done successfully */
return 0;
@ -1980,8 +2005,8 @@ static void s2255_read_video_callback(struct s2255_dev *dev,
}
/* otherwise copy to the system buffers */
res = save_frame(dev, pipe_info);
if (res == EAGAIN)
save_frame(dev, pipe_info);
if (res != 0)
dprintk(4, "s2255: read callback failed\n");
dprintk(50, "callback read video done\n");
return;
@ -2101,11 +2126,9 @@ static int s2255_board_init(struct s2255_dev *dev)
memset(pipe, 0, sizeof(*pipe));
pipe->dev = dev;
pipe->cur_transfer_size = DEFAULT_PIPE_USBBLOCK;
pipe->max_transfer_size = MAX_PIPE_USBBLOCK;
pipe->cur_transfer_size = S2255_USB_XFER_SIZE;
pipe->max_transfer_size = S2255_USB_XFER_SIZE;
if (pipe->cur_transfer_size > pipe->max_transfer_size)
pipe->cur_transfer_size = pipe->max_transfer_size;
pipe->transfer_buffer = kzalloc(pipe->max_transfer_size,
GFP_KERNEL);
if (pipe->transfer_buffer == NULL) {
@ -2329,7 +2352,7 @@ static int s2255_stop_acquire(struct s2255_dev *dev, unsigned long chn)
kfree(buffer);
dev->b_acquire[chn] = 0;
return 0;
return res;
}
static void s2255_stop_readpipe(struct s2255_dev *dev)
@ -2365,8 +2388,10 @@ static void s2255_stop_readpipe(struct s2255_dev *dev)
return;
}
static void s2255_fwload_start(struct s2255_dev *dev)
static void s2255_fwload_start(struct s2255_dev *dev, int reset)
{
if (reset)
s2255_reset_dsppower(dev);
dev->fw_data->fw_size = dev->fw_data->fw->size;
atomic_set(&dev->fw_data->fw_state, S2255_FW_NOTLOADED);
memcpy(dev->fw_data->pfw_data,
@ -2389,6 +2414,8 @@ static int s2255_probe(struct usb_interface *interface,
struct usb_endpoint_descriptor *endpoint;
int i;
int retval = -ENOMEM;
__le32 *pdata;
int fw_size;
dprintk(2, "s2255: probe\n");
@ -2443,6 +2470,8 @@ static int s2255_probe(struct usb_interface *interface,
dev->timer.data = (unsigned long)dev->fw_data;
init_waitqueue_head(&dev->fw_data->wait_fw);
for (i = 0; i < MAX_CHANNELS; i++)
init_waitqueue_head(&dev->wait_setmode[i]);
dev->fw_data->fw_urb = usb_alloc_urb(0, GFP_KERNEL);
@ -2462,16 +2491,30 @@ static int s2255_probe(struct usb_interface *interface,
printk(KERN_ERR "sensoray 2255 failed to get firmware\n");
goto error;
}
/* check the firmware is valid */
fw_size = dev->fw_data->fw->size;
pdata = (__le32 *) &dev->fw_data->fw->data[fw_size - 8];
if (*pdata != S2255_FW_MARKER) {
printk(KERN_INFO "Firmware invalid.\n");
retval = -ENODEV;
goto error;
} else {
/* make sure firmware is the latest */
__le32 *pRel;
pRel = (__le32 *) &dev->fw_data->fw->data[fw_size - 4];
printk(KERN_INFO "s2255 dsp fw version %x\n", *pRel);
}
/* loads v4l specific */
s2255_probe_v4l(dev);
usb_reset_device(dev->udev);
/* load 2255 board specific */
s2255_board_init(dev);
dprintk(4, "before probe done %p\n", dev);
spin_lock_init(&dev->slock);
s2255_fwload_start(dev);
s2255_fwload_start(dev, 0);
dev_info(&interface->dev, "Sensoray 2255 detected\n");
return 0;
error:
@ -2482,14 +2525,30 @@ error:
static void s2255_disconnect(struct usb_interface *interface)
{
struct s2255_dev *dev = NULL;
int i;
dprintk(1, "s2255: disconnect interface %p\n", interface);
dev = usb_get_intfdata(interface);
/*
* wake up any of the timers to allow open_lock to be
* acquired sooner
*/
atomic_set(&dev->fw_data->fw_state, S2255_FW_DISCONNECTING);
wake_up(&dev->fw_data->wait_fw);
for (i = 0; i < MAX_CHANNELS; i++) {
dev->setmode_ready[i] = 1;
wake_up(&dev->wait_setmode[i]);
}
mutex_lock(&dev->open_lock);
usb_set_intfdata(interface, NULL);
mutex_unlock(&dev->open_lock);
if (dev) {
kref_put(&dev->kref, s2255_destroy);
dprintk(1, "s2255drv: disconnect\n");
dev_info(&interface->dev, "s2255usb now disconnected\n");
}
usb_set_intfdata(interface, NULL);
}
static struct usb_driver s2255_driver = {