2019-06-03 05:44:51 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2006-06-26 23:58:46 +00:00
|
|
|
/*
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 2005 Mike Isely <isely@pobox.com>
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include "pvrusb2-io.h"
|
|
|
|
|
#include "pvrusb2-debug.h"
|
|
|
|
|
#include <linux/errno.h>
|
|
|
|
|
#include <linux/string.h>
|
|
|
|
|
#include <linux/slab.h>
|
|
|
|
|
#include <linux/mutex.h>
|
|
|
|
|
|
2006-07-19 01:42:18 +00:00
|
|
|
static const char *pvr2_buffer_state_decode(enum pvr2_buffer_state);
|
|
|
|
|
|
2006-06-26 23:58:46 +00:00
|
|
|
#define BUFFER_SIG 0x47653271
|
|
|
|
|
|
|
|
|
|
// #define SANITY_CHECK_BUFFERS
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef SANITY_CHECK_BUFFERS
|
|
|
|
|
#define BUFFER_CHECK(bp) do { \
|
|
|
|
|
if ((bp)->signature != BUFFER_SIG) { \
|
|
|
|
|
pvr2_trace(PVR2_TRACE_ERROR_LEGS, \
|
|
|
|
|
"Buffer %p is bad at %s:%d", \
|
2016-12-22 19:25:39 +00:00
|
|
|
(bp), __FILE__, __LINE__); \
|
|
|
|
|
pvr2_buffer_describe(bp, "BadSig"); \
|
2006-06-26 23:58:46 +00:00
|
|
|
BUG(); \
|
|
|
|
|
} \
|
|
|
|
|
} while (0)
|
|
|
|
|
#else
|
2016-12-22 19:25:39 +00:00
|
|
|
#define BUFFER_CHECK(bp) do {} while (0)
|
2006-06-26 23:58:46 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
struct pvr2_stream {
|
|
|
|
|
/* Buffers queued for reading */
|
|
|
|
|
struct list_head queued_list;
|
|
|
|
|
unsigned int q_count;
|
|
|
|
|
unsigned int q_bcount;
|
|
|
|
|
/* Buffers with retrieved data */
|
|
|
|
|
struct list_head ready_list;
|
|
|
|
|
unsigned int r_count;
|
|
|
|
|
unsigned int r_bcount;
|
|
|
|
|
/* Buffers available for use */
|
|
|
|
|
struct list_head idle_list;
|
|
|
|
|
unsigned int i_count;
|
|
|
|
|
unsigned int i_bcount;
|
|
|
|
|
/* Pointers to all buffers */
|
|
|
|
|
struct pvr2_buffer **buffers;
|
|
|
|
|
/* Array size of buffers */
|
|
|
|
|
unsigned int buffer_slot_count;
|
|
|
|
|
/* Total buffers actually in circulation */
|
|
|
|
|
unsigned int buffer_total_count;
|
|
|
|
|
/* Designed number of buffers to be in circulation */
|
|
|
|
|
unsigned int buffer_target_count;
|
|
|
|
|
/* Executed when ready list become non-empty */
|
|
|
|
|
pvr2_stream_callback callback_func;
|
|
|
|
|
void *callback_data;
|
|
|
|
|
/* Context for transfer endpoint */
|
|
|
|
|
struct usb_device *dev;
|
|
|
|
|
int endpoint;
|
|
|
|
|
/* Overhead for mutex enforcement */
|
|
|
|
|
spinlock_t list_lock;
|
|
|
|
|
struct mutex mutex;
|
|
|
|
|
/* Tracking state for tolerating errors */
|
|
|
|
|
unsigned int fail_count;
|
|
|
|
|
unsigned int fail_tolerance;
|
2008-03-28 08:34:45 +00:00
|
|
|
|
|
|
|
|
unsigned int buffers_processed;
|
|
|
|
|
unsigned int buffers_failed;
|
|
|
|
|
unsigned int bytes_processed;
|
2006-06-26 23:58:46 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct pvr2_buffer {
|
|
|
|
|
int id;
|
|
|
|
|
int signature;
|
|
|
|
|
enum pvr2_buffer_state state;
|
|
|
|
|
void *ptr; /* Pointer to storage area */
|
|
|
|
|
unsigned int max_count; /* Size of storage area */
|
|
|
|
|
unsigned int used_count; /* Amount of valid data in storage area */
|
|
|
|
|
int status; /* Transfer result status */
|
|
|
|
|
struct pvr2_stream *stream;
|
|
|
|
|
struct list_head list_overhead;
|
|
|
|
|
struct urb *purb;
|
|
|
|
|
};
|
|
|
|
|
|
2006-06-30 14:30:20 +00:00
|
|
|
static const char *pvr2_buffer_state_decode(enum pvr2_buffer_state st)
|
2006-06-26 23:58:46 +00:00
|
|
|
{
|
|
|
|
|
switch (st) {
|
|
|
|
|
case pvr2_buffer_state_none: return "none";
|
|
|
|
|
case pvr2_buffer_state_idle: return "idle";
|
|
|
|
|
case pvr2_buffer_state_queued: return "queued";
|
|
|
|
|
case pvr2_buffer_state_ready: return "ready";
|
|
|
|
|
}
|
|
|
|
|
return "unknown";
|
|
|
|
|
}
|
|
|
|
|
|
2006-06-30 14:30:20 +00:00
|
|
|
#ifdef SANITY_CHECK_BUFFERS
|
2016-12-22 19:25:39 +00:00
|
|
|
static void pvr2_buffer_describe(struct pvr2_buffer *bp, const char *msg)
|
2006-06-26 23:58:46 +00:00
|
|
|
{
|
|
|
|
|
pvr2_trace(PVR2_TRACE_INFO,
|
[media] pvrusb2: don't break long lines
Due to the 80-cols restrictions, and latter due to checkpatch
warnings, several strings were broken into multiple lines. This
is not considered a good practice anymore, as it makes harder
to grep for strings at the source code.
As we're right now fixing other drivers due to KERN_CONT, we need
to be able to identify what printk strings don't end with a "\n".
It is a way easier to detect those if we don't break long lines.
So, join those continuation lines.
The patch was generated via the script below, and manually
adjusted if needed.
</script>
use Text::Tabs;
while (<>) {
if ($next ne "") {
$c=$_;
if ($c =~ /^\s+\"(.*)/) {
$c2=$1;
$next =~ s/\"\n$//;
$n = expand($next);
$funpos = index($n, '(');
$pos = index($c2, '",');
if ($funpos && $pos > 0) {
$s1 = substr $c2, 0, $pos + 2;
$s2 = ' ' x ($funpos + 1) . substr $c2, $pos + 2;
$s2 =~ s/^\s+//;
$s2 = ' ' x ($funpos + 1) . $s2 if ($s2 ne "");
print unexpand("$next$s1\n");
print unexpand("$s2\n") if ($s2 ne "");
} else {
print "$next$c2\n";
}
$next="";
next;
} else {
print $next;
}
$next="";
} else {
if (m/\"$/) {
if (!m/\\n\"$/) {
$next=$_;
next;
}
}
}
print $_;
}
</script>
Signed-off-by: Mauro Carvalho Chehab <mchehab@s-opensource.com>
2016-10-18 19:44:18 +00:00
|
|
|
"buffer%s%s %p state=%s id=%d status=%d stream=%p purb=%p sig=0x%x",
|
2006-06-26 23:58:46 +00:00
|
|
|
(msg ? " " : ""),
|
|
|
|
|
(msg ? msg : ""),
|
|
|
|
|
bp,
|
|
|
|
|
(bp ? pvr2_buffer_state_decode(bp->state) : "(invalid)"),
|
|
|
|
|
(bp ? bp->id : 0),
|
|
|
|
|
(bp ? bp->status : 0),
|
2006-06-30 14:35:28 +00:00
|
|
|
(bp ? bp->stream : NULL),
|
|
|
|
|
(bp ? bp->purb : NULL),
|
2006-06-26 23:58:46 +00:00
|
|
|
(bp ? bp->signature : 0));
|
|
|
|
|
}
|
2006-06-30 14:30:20 +00:00
|
|
|
#endif /* SANITY_CHECK_BUFFERS */
|
2006-06-26 23:58:46 +00:00
|
|
|
|
|
|
|
|
static void pvr2_buffer_remove(struct pvr2_buffer *bp)
|
|
|
|
|
{
|
|
|
|
|
unsigned int *cnt;
|
|
|
|
|
unsigned int *bcnt;
|
|
|
|
|
unsigned int ccnt;
|
|
|
|
|
struct pvr2_stream *sp = bp->stream;
|
|
|
|
|
switch (bp->state) {
|
|
|
|
|
case pvr2_buffer_state_idle:
|
|
|
|
|
cnt = &sp->i_count;
|
|
|
|
|
bcnt = &sp->i_bcount;
|
|
|
|
|
ccnt = bp->max_count;
|
|
|
|
|
break;
|
|
|
|
|
case pvr2_buffer_state_queued:
|
|
|
|
|
cnt = &sp->q_count;
|
|
|
|
|
bcnt = &sp->q_bcount;
|
|
|
|
|
ccnt = bp->max_count;
|
|
|
|
|
break;
|
|
|
|
|
case pvr2_buffer_state_ready:
|
|
|
|
|
cnt = &sp->r_count;
|
|
|
|
|
bcnt = &sp->r_bcount;
|
|
|
|
|
ccnt = bp->used_count;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
list_del_init(&bp->list_overhead);
|
|
|
|
|
(*cnt)--;
|
|
|
|
|
(*bcnt) -= ccnt;
|
|
|
|
|
pvr2_trace(PVR2_TRACE_BUF_FLOW,
|
[media] pvrusb2: don't break long lines
Due to the 80-cols restrictions, and latter due to checkpatch
warnings, several strings were broken into multiple lines. This
is not considered a good practice anymore, as it makes harder
to grep for strings at the source code.
As we're right now fixing other drivers due to KERN_CONT, we need
to be able to identify what printk strings don't end with a "\n".
It is a way easier to detect those if we don't break long lines.
So, join those continuation lines.
The patch was generated via the script below, and manually
adjusted if needed.
</script>
use Text::Tabs;
while (<>) {
if ($next ne "") {
$c=$_;
if ($c =~ /^\s+\"(.*)/) {
$c2=$1;
$next =~ s/\"\n$//;
$n = expand($next);
$funpos = index($n, '(');
$pos = index($c2, '",');
if ($funpos && $pos > 0) {
$s1 = substr $c2, 0, $pos + 2;
$s2 = ' ' x ($funpos + 1) . substr $c2, $pos + 2;
$s2 =~ s/^\s+//;
$s2 = ' ' x ($funpos + 1) . $s2 if ($s2 ne "");
print unexpand("$next$s1\n");
print unexpand("$s2\n") if ($s2 ne "");
} else {
print "$next$c2\n";
}
$next="";
next;
} else {
print $next;
}
$next="";
} else {
if (m/\"$/) {
if (!m/\\n\"$/) {
$next=$_;
next;
}
}
}
print $_;
}
</script>
Signed-off-by: Mauro Carvalho Chehab <mchehab@s-opensource.com>
2016-10-18 19:44:18 +00:00
|
|
|
"/*---TRACE_FLOW---*/ bufferPool %8s dec cap=%07d cnt=%02d",
|
2016-12-22 19:25:39 +00:00
|
|
|
pvr2_buffer_state_decode(bp->state), *bcnt, *cnt);
|
2006-06-26 23:58:46 +00:00
|
|
|
bp->state = pvr2_buffer_state_none;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void pvr2_buffer_set_none(struct pvr2_buffer *bp)
|
|
|
|
|
{
|
|
|
|
|
unsigned long irq_flags;
|
|
|
|
|
struct pvr2_stream *sp;
|
|
|
|
|
BUFFER_CHECK(bp);
|
|
|
|
|
sp = bp->stream;
|
|
|
|
|
pvr2_trace(PVR2_TRACE_BUF_FLOW,
|
|
|
|
|
"/*---TRACE_FLOW---*/ bufferState %p %6s --> %6s",
|
|
|
|
|
bp,
|
|
|
|
|
pvr2_buffer_state_decode(bp->state),
|
|
|
|
|
pvr2_buffer_state_decode(pvr2_buffer_state_none));
|
2016-12-22 19:25:39 +00:00
|
|
|
spin_lock_irqsave(&sp->list_lock, irq_flags);
|
2006-06-26 23:58:46 +00:00
|
|
|
pvr2_buffer_remove(bp);
|
2016-12-22 19:25:39 +00:00
|
|
|
spin_unlock_irqrestore(&sp->list_lock, irq_flags);
|
2006-06-26 23:58:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int pvr2_buffer_set_ready(struct pvr2_buffer *bp)
|
|
|
|
|
{
|
|
|
|
|
int fl;
|
|
|
|
|
unsigned long irq_flags;
|
|
|
|
|
struct pvr2_stream *sp;
|
|
|
|
|
BUFFER_CHECK(bp);
|
|
|
|
|
sp = bp->stream;
|
|
|
|
|
pvr2_trace(PVR2_TRACE_BUF_FLOW,
|
|
|
|
|
"/*---TRACE_FLOW---*/ bufferState %p %6s --> %6s",
|
|
|
|
|
bp,
|
|
|
|
|
pvr2_buffer_state_decode(bp->state),
|
|
|
|
|
pvr2_buffer_state_decode(pvr2_buffer_state_ready));
|
2016-12-22 19:25:39 +00:00
|
|
|
spin_lock_irqsave(&sp->list_lock, irq_flags);
|
2006-06-26 23:58:46 +00:00
|
|
|
fl = (sp->r_count == 0);
|
|
|
|
|
pvr2_buffer_remove(bp);
|
2016-12-22 19:25:39 +00:00
|
|
|
list_add_tail(&bp->list_overhead, &sp->ready_list);
|
2006-06-26 23:58:46 +00:00
|
|
|
bp->state = pvr2_buffer_state_ready;
|
|
|
|
|
(sp->r_count)++;
|
|
|
|
|
sp->r_bcount += bp->used_count;
|
|
|
|
|
pvr2_trace(PVR2_TRACE_BUF_FLOW,
|
[media] pvrusb2: don't break long lines
Due to the 80-cols restrictions, and latter due to checkpatch
warnings, several strings were broken into multiple lines. This
is not considered a good practice anymore, as it makes harder
to grep for strings at the source code.
As we're right now fixing other drivers due to KERN_CONT, we need
to be able to identify what printk strings don't end with a "\n".
It is a way easier to detect those if we don't break long lines.
So, join those continuation lines.
The patch was generated via the script below, and manually
adjusted if needed.
</script>
use Text::Tabs;
while (<>) {
if ($next ne "") {
$c=$_;
if ($c =~ /^\s+\"(.*)/) {
$c2=$1;
$next =~ s/\"\n$//;
$n = expand($next);
$funpos = index($n, '(');
$pos = index($c2, '",');
if ($funpos && $pos > 0) {
$s1 = substr $c2, 0, $pos + 2;
$s2 = ' ' x ($funpos + 1) . substr $c2, $pos + 2;
$s2 =~ s/^\s+//;
$s2 = ' ' x ($funpos + 1) . $s2 if ($s2 ne "");
print unexpand("$next$s1\n");
print unexpand("$s2\n") if ($s2 ne "");
} else {
print "$next$c2\n";
}
$next="";
next;
} else {
print $next;
}
$next="";
} else {
if (m/\"$/) {
if (!m/\\n\"$/) {
$next=$_;
next;
}
}
}
print $_;
}
</script>
Signed-off-by: Mauro Carvalho Chehab <mchehab@s-opensource.com>
2016-10-18 19:44:18 +00:00
|
|
|
"/*---TRACE_FLOW---*/ bufferPool %8s inc cap=%07d cnt=%02d",
|
2006-06-26 23:58:46 +00:00
|
|
|
pvr2_buffer_state_decode(bp->state),
|
2016-12-22 19:25:39 +00:00
|
|
|
sp->r_bcount, sp->r_count);
|
|
|
|
|
spin_unlock_irqrestore(&sp->list_lock, irq_flags);
|
2006-06-26 23:58:46 +00:00
|
|
|
return fl;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void pvr2_buffer_set_idle(struct pvr2_buffer *bp)
|
|
|
|
|
{
|
|
|
|
|
unsigned long irq_flags;
|
|
|
|
|
struct pvr2_stream *sp;
|
|
|
|
|
BUFFER_CHECK(bp);
|
|
|
|
|
sp = bp->stream;
|
|
|
|
|
pvr2_trace(PVR2_TRACE_BUF_FLOW,
|
|
|
|
|
"/*---TRACE_FLOW---*/ bufferState %p %6s --> %6s",
|
|
|
|
|
bp,
|
|
|
|
|
pvr2_buffer_state_decode(bp->state),
|
|
|
|
|
pvr2_buffer_state_decode(pvr2_buffer_state_idle));
|
2016-12-22 19:25:39 +00:00
|
|
|
spin_lock_irqsave(&sp->list_lock, irq_flags);
|
2006-06-26 23:58:46 +00:00
|
|
|
pvr2_buffer_remove(bp);
|
2016-12-22 19:25:39 +00:00
|
|
|
list_add_tail(&bp->list_overhead, &sp->idle_list);
|
2006-06-26 23:58:46 +00:00
|
|
|
bp->state = pvr2_buffer_state_idle;
|
|
|
|
|
(sp->i_count)++;
|
|
|
|
|
sp->i_bcount += bp->max_count;
|
|
|
|
|
pvr2_trace(PVR2_TRACE_BUF_FLOW,
|
[media] pvrusb2: don't break long lines
Due to the 80-cols restrictions, and latter due to checkpatch
warnings, several strings were broken into multiple lines. This
is not considered a good practice anymore, as it makes harder
to grep for strings at the source code.
As we're right now fixing other drivers due to KERN_CONT, we need
to be able to identify what printk strings don't end with a "\n".
It is a way easier to detect those if we don't break long lines.
So, join those continuation lines.
The patch was generated via the script below, and manually
adjusted if needed.
</script>
use Text::Tabs;
while (<>) {
if ($next ne "") {
$c=$_;
if ($c =~ /^\s+\"(.*)/) {
$c2=$1;
$next =~ s/\"\n$//;
$n = expand($next);
$funpos = index($n, '(');
$pos = index($c2, '",');
if ($funpos && $pos > 0) {
$s1 = substr $c2, 0, $pos + 2;
$s2 = ' ' x ($funpos + 1) . substr $c2, $pos + 2;
$s2 =~ s/^\s+//;
$s2 = ' ' x ($funpos + 1) . $s2 if ($s2 ne "");
print unexpand("$next$s1\n");
print unexpand("$s2\n") if ($s2 ne "");
} else {
print "$next$c2\n";
}
$next="";
next;
} else {
print $next;
}
$next="";
} else {
if (m/\"$/) {
if (!m/\\n\"$/) {
$next=$_;
next;
}
}
}
print $_;
}
</script>
Signed-off-by: Mauro Carvalho Chehab <mchehab@s-opensource.com>
2016-10-18 19:44:18 +00:00
|
|
|
"/*---TRACE_FLOW---*/ bufferPool %8s inc cap=%07d cnt=%02d",
|
2006-06-26 23:58:46 +00:00
|
|
|
pvr2_buffer_state_decode(bp->state),
|
2016-12-22 19:25:39 +00:00
|
|
|
sp->i_bcount, sp->i_count);
|
|
|
|
|
spin_unlock_irqrestore(&sp->list_lock, irq_flags);
|
2006-06-26 23:58:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void pvr2_buffer_set_queued(struct pvr2_buffer *bp)
|
|
|
|
|
{
|
|
|
|
|
unsigned long irq_flags;
|
|
|
|
|
struct pvr2_stream *sp;
|
|
|
|
|
BUFFER_CHECK(bp);
|
|
|
|
|
sp = bp->stream;
|
|
|
|
|
pvr2_trace(PVR2_TRACE_BUF_FLOW,
|
|
|
|
|
"/*---TRACE_FLOW---*/ bufferState %p %6s --> %6s",
|
|
|
|
|
bp,
|
|
|
|
|
pvr2_buffer_state_decode(bp->state),
|
|
|
|
|
pvr2_buffer_state_decode(pvr2_buffer_state_queued));
|
2016-12-22 19:25:39 +00:00
|
|
|
spin_lock_irqsave(&sp->list_lock, irq_flags);
|
2006-06-26 23:58:46 +00:00
|
|
|
pvr2_buffer_remove(bp);
|
2016-12-22 19:25:39 +00:00
|
|
|
list_add_tail(&bp->list_overhead, &sp->queued_list);
|
2006-06-26 23:58:46 +00:00
|
|
|
bp->state = pvr2_buffer_state_queued;
|
|
|
|
|
(sp->q_count)++;
|
|
|
|
|
sp->q_bcount += bp->max_count;
|
|
|
|
|
pvr2_trace(PVR2_TRACE_BUF_FLOW,
|
[media] pvrusb2: don't break long lines
Due to the 80-cols restrictions, and latter due to checkpatch
warnings, several strings were broken into multiple lines. This
is not considered a good practice anymore, as it makes harder
to grep for strings at the source code.
As we're right now fixing other drivers due to KERN_CONT, we need
to be able to identify what printk strings don't end with a "\n".
It is a way easier to detect those if we don't break long lines.
So, join those continuation lines.
The patch was generated via the script below, and manually
adjusted if needed.
</script>
use Text::Tabs;
while (<>) {
if ($next ne "") {
$c=$_;
if ($c =~ /^\s+\"(.*)/) {
$c2=$1;
$next =~ s/\"\n$//;
$n = expand($next);
$funpos = index($n, '(');
$pos = index($c2, '",');
if ($funpos && $pos > 0) {
$s1 = substr $c2, 0, $pos + 2;
$s2 = ' ' x ($funpos + 1) . substr $c2, $pos + 2;
$s2 =~ s/^\s+//;
$s2 = ' ' x ($funpos + 1) . $s2 if ($s2 ne "");
print unexpand("$next$s1\n");
print unexpand("$s2\n") if ($s2 ne "");
} else {
print "$next$c2\n";
}
$next="";
next;
} else {
print $next;
}
$next="";
} else {
if (m/\"$/) {
if (!m/\\n\"$/) {
$next=$_;
next;
}
}
}
print $_;
}
</script>
Signed-off-by: Mauro Carvalho Chehab <mchehab@s-opensource.com>
2016-10-18 19:44:18 +00:00
|
|
|
"/*---TRACE_FLOW---*/ bufferPool %8s inc cap=%07d cnt=%02d",
|
2006-06-26 23:58:46 +00:00
|
|
|
pvr2_buffer_state_decode(bp->state),
|
2016-12-22 19:25:39 +00:00
|
|
|
sp->q_bcount, sp->q_count);
|
|
|
|
|
spin_unlock_irqrestore(&sp->list_lock, irq_flags);
|
2006-06-26 23:58:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void pvr2_buffer_wipe(struct pvr2_buffer *bp)
|
|
|
|
|
{
|
|
|
|
|
if (bp->state == pvr2_buffer_state_queued) {
|
|
|
|
|
usb_kill_urb(bp->purb);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int pvr2_buffer_init(struct pvr2_buffer *bp,
|
|
|
|
|
struct pvr2_stream *sp,
|
|
|
|
|
unsigned int id)
|
|
|
|
|
{
|
2016-12-22 19:25:39 +00:00
|
|
|
memset(bp, 0, sizeof(*bp));
|
2006-06-26 23:58:46 +00:00
|
|
|
bp->signature = BUFFER_SIG;
|
|
|
|
|
bp->id = id;
|
|
|
|
|
pvr2_trace(PVR2_TRACE_BUF_POOL,
|
2016-12-22 19:25:39 +00:00
|
|
|
"/*---TRACE_FLOW---*/ bufferInit %p stream=%p", bp, sp);
|
2006-06-26 23:58:46 +00:00
|
|
|
bp->stream = sp;
|
|
|
|
|
bp->state = pvr2_buffer_state_none;
|
|
|
|
|
INIT_LIST_HEAD(&bp->list_overhead);
|
2016-12-22 19:25:39 +00:00
|
|
|
bp->purb = usb_alloc_urb(0, GFP_KERNEL);
|
2006-06-26 23:58:46 +00:00
|
|
|
if (! bp->purb) return -ENOMEM;
|
|
|
|
|
#ifdef SANITY_CHECK_BUFFERS
|
2016-12-22 19:25:39 +00:00
|
|
|
pvr2_buffer_describe(bp, "create");
|
2006-06-26 23:58:46 +00:00
|
|
|
#endif
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void pvr2_buffer_done(struct pvr2_buffer *bp)
|
|
|
|
|
{
|
|
|
|
|
#ifdef SANITY_CHECK_BUFFERS
|
2016-12-22 19:25:39 +00:00
|
|
|
pvr2_buffer_describe(bp, "delete");
|
2006-06-26 23:58:46 +00:00
|
|
|
#endif
|
|
|
|
|
pvr2_buffer_wipe(bp);
|
|
|
|
|
pvr2_buffer_set_none(bp);
|
|
|
|
|
bp->signature = 0;
|
2006-06-30 14:35:28 +00:00
|
|
|
bp->stream = NULL;
|
2006-11-08 14:34:50 +00:00
|
|
|
usb_free_urb(bp->purb);
|
[media] pvrusb2: don't break long lines
Due to the 80-cols restrictions, and latter due to checkpatch
warnings, several strings were broken into multiple lines. This
is not considered a good practice anymore, as it makes harder
to grep for strings at the source code.
As we're right now fixing other drivers due to KERN_CONT, we need
to be able to identify what printk strings don't end with a "\n".
It is a way easier to detect those if we don't break long lines.
So, join those continuation lines.
The patch was generated via the script below, and manually
adjusted if needed.
</script>
use Text::Tabs;
while (<>) {
if ($next ne "") {
$c=$_;
if ($c =~ /^\s+\"(.*)/) {
$c2=$1;
$next =~ s/\"\n$//;
$n = expand($next);
$funpos = index($n, '(');
$pos = index($c2, '",');
if ($funpos && $pos > 0) {
$s1 = substr $c2, 0, $pos + 2;
$s2 = ' ' x ($funpos + 1) . substr $c2, $pos + 2;
$s2 =~ s/^\s+//;
$s2 = ' ' x ($funpos + 1) . $s2 if ($s2 ne "");
print unexpand("$next$s1\n");
print unexpand("$s2\n") if ($s2 ne "");
} else {
print "$next$c2\n";
}
$next="";
next;
} else {
print $next;
}
$next="";
} else {
if (m/\"$/) {
if (!m/\\n\"$/) {
$next=$_;
next;
}
}
}
print $_;
}
</script>
Signed-off-by: Mauro Carvalho Chehab <mchehab@s-opensource.com>
2016-10-18 19:44:18 +00:00
|
|
|
pvr2_trace(PVR2_TRACE_BUF_POOL, "/*---TRACE_FLOW---*/ bufferDone %p",
|
|
|
|
|
bp);
|
2006-06-26 23:58:46 +00:00
|
|
|
}
|
|
|
|
|
|
2016-12-22 19:25:39 +00:00
|
|
|
static int pvr2_stream_buffer_count(struct pvr2_stream *sp, unsigned int cnt)
|
2006-06-26 23:58:46 +00:00
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
unsigned int scnt;
|
|
|
|
|
|
|
|
|
|
/* Allocate buffers pointer array in multiples of 32 entries */
|
|
|
|
|
if (cnt == sp->buffer_total_count) return 0;
|
|
|
|
|
|
|
|
|
|
pvr2_trace(PVR2_TRACE_BUF_POOL,
|
[media] pvrusb2: don't break long lines
Due to the 80-cols restrictions, and latter due to checkpatch
warnings, several strings were broken into multiple lines. This
is not considered a good practice anymore, as it makes harder
to grep for strings at the source code.
As we're right now fixing other drivers due to KERN_CONT, we need
to be able to identify what printk strings don't end with a "\n".
It is a way easier to detect those if we don't break long lines.
So, join those continuation lines.
The patch was generated via the script below, and manually
adjusted if needed.
</script>
use Text::Tabs;
while (<>) {
if ($next ne "") {
$c=$_;
if ($c =~ /^\s+\"(.*)/) {
$c2=$1;
$next =~ s/\"\n$//;
$n = expand($next);
$funpos = index($n, '(');
$pos = index($c2, '",');
if ($funpos && $pos > 0) {
$s1 = substr $c2, 0, $pos + 2;
$s2 = ' ' x ($funpos + 1) . substr $c2, $pos + 2;
$s2 =~ s/^\s+//;
$s2 = ' ' x ($funpos + 1) . $s2 if ($s2 ne "");
print unexpand("$next$s1\n");
print unexpand("$s2\n") if ($s2 ne "");
} else {
print "$next$c2\n";
}
$next="";
next;
} else {
print $next;
}
$next="";
} else {
if (m/\"$/) {
if (!m/\\n\"$/) {
$next=$_;
next;
}
}
}
print $_;
}
</script>
Signed-off-by: Mauro Carvalho Chehab <mchehab@s-opensource.com>
2016-10-18 19:44:18 +00:00
|
|
|
"/*---TRACE_FLOW---*/ poolResize stream=%p cur=%d adj=%+d",
|
2006-06-26 23:58:46 +00:00
|
|
|
sp,
|
|
|
|
|
sp->buffer_total_count,
|
|
|
|
|
cnt-sp->buffer_total_count);
|
|
|
|
|
|
|
|
|
|
scnt = cnt & ~0x1f;
|
|
|
|
|
if (cnt > scnt) scnt += 0x20;
|
|
|
|
|
|
|
|
|
|
if (cnt > sp->buffer_total_count) {
|
|
|
|
|
if (scnt > sp->buffer_slot_count) {
|
|
|
|
|
struct pvr2_buffer **nb;
|
2016-12-22 18:26:52 +00:00
|
|
|
|
|
|
|
|
nb = kmalloc_array(scnt, sizeof(*nb), GFP_KERNEL);
|
2006-06-26 23:58:46 +00:00
|
|
|
if (!nb) return -ENOMEM;
|
|
|
|
|
if (sp->buffer_slot_count) {
|
2016-12-22 19:25:39 +00:00
|
|
|
memcpy(nb, sp->buffers,
|
2006-06-26 23:58:46 +00:00
|
|
|
sp->buffer_slot_count * sizeof(*nb));
|
|
|
|
|
kfree(sp->buffers);
|
|
|
|
|
}
|
|
|
|
|
sp->buffers = nb;
|
|
|
|
|
sp->buffer_slot_count = scnt;
|
|
|
|
|
}
|
|
|
|
|
while (sp->buffer_total_count < cnt) {
|
|
|
|
|
struct pvr2_buffer *bp;
|
2016-12-22 19:25:39 +00:00
|
|
|
bp = kmalloc(sizeof(*bp), GFP_KERNEL);
|
2006-06-26 23:58:46 +00:00
|
|
|
if (!bp) return -ENOMEM;
|
2016-12-22 19:25:39 +00:00
|
|
|
ret = pvr2_buffer_init(bp, sp, sp->buffer_total_count);
|
2006-06-26 23:58:46 +00:00
|
|
|
if (ret) {
|
|
|
|
|
kfree(bp);
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
}
|
|
|
|
|
sp->buffers[sp->buffer_total_count] = bp;
|
|
|
|
|
(sp->buffer_total_count)++;
|
|
|
|
|
pvr2_buffer_set_idle(bp);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
while (sp->buffer_total_count > cnt) {
|
|
|
|
|
struct pvr2_buffer *bp;
|
|
|
|
|
bp = sp->buffers[sp->buffer_total_count - 1];
|
|
|
|
|
/* Paranoia */
|
2006-06-30 14:35:28 +00:00
|
|
|
sp->buffers[sp->buffer_total_count - 1] = NULL;
|
2006-06-26 23:58:46 +00:00
|
|
|
(sp->buffer_total_count)--;
|
|
|
|
|
pvr2_buffer_done(bp);
|
|
|
|
|
kfree(bp);
|
|
|
|
|
}
|
|
|
|
|
if (scnt < sp->buffer_slot_count) {
|
2006-06-30 14:35:28 +00:00
|
|
|
struct pvr2_buffer **nb = NULL;
|
2006-06-26 23:58:46 +00:00
|
|
|
if (scnt) {
|
2013-06-01 08:38:30 +00:00
|
|
|
nb = kmemdup(sp->buffers, scnt * sizeof(*nb),
|
|
|
|
|
GFP_KERNEL);
|
2006-06-26 23:58:46 +00:00
|
|
|
if (!nb) return -ENOMEM;
|
|
|
|
|
}
|
|
|
|
|
kfree(sp->buffers);
|
|
|
|
|
sp->buffers = nb;
|
|
|
|
|
sp->buffer_slot_count = scnt;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int pvr2_stream_achieve_buffer_count(struct pvr2_stream *sp)
|
|
|
|
|
{
|
|
|
|
|
struct pvr2_buffer *bp;
|
|
|
|
|
unsigned int cnt;
|
|
|
|
|
|
|
|
|
|
if (sp->buffer_total_count == sp->buffer_target_count) return 0;
|
|
|
|
|
|
|
|
|
|
pvr2_trace(PVR2_TRACE_BUF_POOL,
|
[media] pvrusb2: don't break long lines
Due to the 80-cols restrictions, and latter due to checkpatch
warnings, several strings were broken into multiple lines. This
is not considered a good practice anymore, as it makes harder
to grep for strings at the source code.
As we're right now fixing other drivers due to KERN_CONT, we need
to be able to identify what printk strings don't end with a "\n".
It is a way easier to detect those if we don't break long lines.
So, join those continuation lines.
The patch was generated via the script below, and manually
adjusted if needed.
</script>
use Text::Tabs;
while (<>) {
if ($next ne "") {
$c=$_;
if ($c =~ /^\s+\"(.*)/) {
$c2=$1;
$next =~ s/\"\n$//;
$n = expand($next);
$funpos = index($n, '(');
$pos = index($c2, '",');
if ($funpos && $pos > 0) {
$s1 = substr $c2, 0, $pos + 2;
$s2 = ' ' x ($funpos + 1) . substr $c2, $pos + 2;
$s2 =~ s/^\s+//;
$s2 = ' ' x ($funpos + 1) . $s2 if ($s2 ne "");
print unexpand("$next$s1\n");
print unexpand("$s2\n") if ($s2 ne "");
} else {
print "$next$c2\n";
}
$next="";
next;
} else {
print $next;
}
$next="";
} else {
if (m/\"$/) {
if (!m/\\n\"$/) {
$next=$_;
next;
}
}
}
print $_;
}
</script>
Signed-off-by: Mauro Carvalho Chehab <mchehab@s-opensource.com>
2016-10-18 19:44:18 +00:00
|
|
|
"/*---TRACE_FLOW---*/ poolCheck stream=%p cur=%d tgt=%d",
|
2016-12-22 19:25:39 +00:00
|
|
|
sp, sp->buffer_total_count, sp->buffer_target_count);
|
2006-06-26 23:58:46 +00:00
|
|
|
|
|
|
|
|
if (sp->buffer_total_count < sp->buffer_target_count) {
|
2016-12-22 19:25:39 +00:00
|
|
|
return pvr2_stream_buffer_count(sp, sp->buffer_target_count);
|
2006-06-26 23:58:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cnt = 0;
|
|
|
|
|
while ((sp->buffer_total_count - cnt) > sp->buffer_target_count) {
|
|
|
|
|
bp = sp->buffers[sp->buffer_total_count - (cnt + 1)];
|
|
|
|
|
if (bp->state != pvr2_buffer_state_idle) break;
|
|
|
|
|
cnt++;
|
|
|
|
|
}
|
|
|
|
|
if (cnt) {
|
2016-12-22 19:25:39 +00:00
|
|
|
pvr2_stream_buffer_count(sp, sp->buffer_total_count - cnt);
|
2006-06-26 23:58:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void pvr2_stream_internal_flush(struct pvr2_stream *sp)
|
|
|
|
|
{
|
|
|
|
|
struct list_head *lp;
|
|
|
|
|
struct pvr2_buffer *bp1;
|
|
|
|
|
while ((lp = sp->queued_list.next) != &sp->queued_list) {
|
2016-12-22 19:25:39 +00:00
|
|
|
bp1 = list_entry(lp, struct pvr2_buffer, list_overhead);
|
2006-06-26 23:58:46 +00:00
|
|
|
pvr2_buffer_wipe(bp1);
|
|
|
|
|
/* At this point, we should be guaranteed that no
|
|
|
|
|
completion callback may happen on this buffer. But it's
|
|
|
|
|
possible that it might have completed after we noticed
|
|
|
|
|
it but before we wiped it. So double check its status
|
|
|
|
|
here first. */
|
|
|
|
|
if (bp1->state != pvr2_buffer_state_queued) continue;
|
|
|
|
|
pvr2_buffer_set_idle(bp1);
|
|
|
|
|
}
|
|
|
|
|
if (sp->buffer_total_count != sp->buffer_target_count) {
|
|
|
|
|
pvr2_stream_achieve_buffer_count(sp);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void pvr2_stream_init(struct pvr2_stream *sp)
|
|
|
|
|
{
|
|
|
|
|
spin_lock_init(&sp->list_lock);
|
|
|
|
|
mutex_init(&sp->mutex);
|
|
|
|
|
INIT_LIST_HEAD(&sp->queued_list);
|
|
|
|
|
INIT_LIST_HEAD(&sp->ready_list);
|
|
|
|
|
INIT_LIST_HEAD(&sp->idle_list);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void pvr2_stream_done(struct pvr2_stream *sp)
|
|
|
|
|
{
|
|
|
|
|
mutex_lock(&sp->mutex); do {
|
|
|
|
|
pvr2_stream_internal_flush(sp);
|
2016-12-22 19:25:39 +00:00
|
|
|
pvr2_stream_buffer_count(sp, 0);
|
2006-06-26 23:58:46 +00:00
|
|
|
} while (0); mutex_unlock(&sp->mutex);
|
|
|
|
|
}
|
|
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 13:55:46 +00:00
|
|
|
static void buffer_complete(struct urb *urb)
|
2006-06-26 23:58:46 +00:00
|
|
|
{
|
|
|
|
|
struct pvr2_buffer *bp = urb->context;
|
|
|
|
|
struct pvr2_stream *sp;
|
|
|
|
|
unsigned long irq_flags;
|
|
|
|
|
BUFFER_CHECK(bp);
|
|
|
|
|
sp = bp->stream;
|
|
|
|
|
bp->used_count = 0;
|
|
|
|
|
bp->status = 0;
|
|
|
|
|
pvr2_trace(PVR2_TRACE_BUF_FLOW,
|
|
|
|
|
"/*---TRACE_FLOW---*/ bufferComplete %p stat=%d cnt=%d",
|
2016-12-22 19:25:39 +00:00
|
|
|
bp, urb->status, urb->actual_length);
|
|
|
|
|
spin_lock_irqsave(&sp->list_lock, irq_flags);
|
2006-06-26 23:58:46 +00:00
|
|
|
if ((!(urb->status)) ||
|
|
|
|
|
(urb->status == -ENOENT) ||
|
|
|
|
|
(urb->status == -ECONNRESET) ||
|
|
|
|
|
(urb->status == -ESHUTDOWN)) {
|
2008-03-28 08:34:45 +00:00
|
|
|
(sp->buffers_processed)++;
|
|
|
|
|
sp->bytes_processed += urb->actual_length;
|
2006-06-26 23:58:46 +00:00
|
|
|
bp->used_count = urb->actual_length;
|
|
|
|
|
if (sp->fail_count) {
|
|
|
|
|
pvr2_trace(PVR2_TRACE_TOLERANCE,
|
[media] pvrusb2: don't break long lines
Due to the 80-cols restrictions, and latter due to checkpatch
warnings, several strings were broken into multiple lines. This
is not considered a good practice anymore, as it makes harder
to grep for strings at the source code.
As we're right now fixing other drivers due to KERN_CONT, we need
to be able to identify what printk strings don't end with a "\n".
It is a way easier to detect those if we don't break long lines.
So, join those continuation lines.
The patch was generated via the script below, and manually
adjusted if needed.
</script>
use Text::Tabs;
while (<>) {
if ($next ne "") {
$c=$_;
if ($c =~ /^\s+\"(.*)/) {
$c2=$1;
$next =~ s/\"\n$//;
$n = expand($next);
$funpos = index($n, '(');
$pos = index($c2, '",');
if ($funpos && $pos > 0) {
$s1 = substr $c2, 0, $pos + 2;
$s2 = ' ' x ($funpos + 1) . substr $c2, $pos + 2;
$s2 =~ s/^\s+//;
$s2 = ' ' x ($funpos + 1) . $s2 if ($s2 ne "");
print unexpand("$next$s1\n");
print unexpand("$s2\n") if ($s2 ne "");
} else {
print "$next$c2\n";
}
$next="";
next;
} else {
print $next;
}
$next="";
} else {
if (m/\"$/) {
if (!m/\\n\"$/) {
$next=$_;
next;
}
}
}
print $_;
}
</script>
Signed-off-by: Mauro Carvalho Chehab <mchehab@s-opensource.com>
2016-10-18 19:44:18 +00:00
|
|
|
"stream %p transfer ok - fail count reset",
|
|
|
|
|
sp);
|
2006-06-26 23:58:46 +00:00
|
|
|
sp->fail_count = 0;
|
|
|
|
|
}
|
|
|
|
|
} else if (sp->fail_count < sp->fail_tolerance) {
|
|
|
|
|
// We can tolerate this error, because we're below the
|
|
|
|
|
// threshold...
|
|
|
|
|
(sp->fail_count)++;
|
2008-03-28 08:34:45 +00:00
|
|
|
(sp->buffers_failed)++;
|
2006-06-26 23:58:46 +00:00
|
|
|
pvr2_trace(PVR2_TRACE_TOLERANCE,
|
[media] pvrusb2: don't break long lines
Due to the 80-cols restrictions, and latter due to checkpatch
warnings, several strings were broken into multiple lines. This
is not considered a good practice anymore, as it makes harder
to grep for strings at the source code.
As we're right now fixing other drivers due to KERN_CONT, we need
to be able to identify what printk strings don't end with a "\n".
It is a way easier to detect those if we don't break long lines.
So, join those continuation lines.
The patch was generated via the script below, and manually
adjusted if needed.
</script>
use Text::Tabs;
while (<>) {
if ($next ne "") {
$c=$_;
if ($c =~ /^\s+\"(.*)/) {
$c2=$1;
$next =~ s/\"\n$//;
$n = expand($next);
$funpos = index($n, '(');
$pos = index($c2, '",');
if ($funpos && $pos > 0) {
$s1 = substr $c2, 0, $pos + 2;
$s2 = ' ' x ($funpos + 1) . substr $c2, $pos + 2;
$s2 =~ s/^\s+//;
$s2 = ' ' x ($funpos + 1) . $s2 if ($s2 ne "");
print unexpand("$next$s1\n");
print unexpand("$s2\n") if ($s2 ne "");
} else {
print "$next$c2\n";
}
$next="";
next;
} else {
print $next;
}
$next="";
} else {
if (m/\"$/) {
if (!m/\\n\"$/) {
$next=$_;
next;
}
}
}
print $_;
}
</script>
Signed-off-by: Mauro Carvalho Chehab <mchehab@s-opensource.com>
2016-10-18 19:44:18 +00:00
|
|
|
"stream %p ignoring error %d - fail count increased to %u",
|
2016-12-22 19:25:39 +00:00
|
|
|
sp, urb->status, sp->fail_count);
|
2006-06-26 23:58:46 +00:00
|
|
|
} else {
|
2008-03-28 08:34:45 +00:00
|
|
|
(sp->buffers_failed)++;
|
2006-06-26 23:58:46 +00:00
|
|
|
bp->status = urb->status;
|
|
|
|
|
}
|
2016-12-22 19:25:39 +00:00
|
|
|
spin_unlock_irqrestore(&sp->list_lock, irq_flags);
|
2006-06-26 23:58:46 +00:00
|
|
|
pvr2_buffer_set_ready(bp);
|
2016-02-22 16:02:36 +00:00
|
|
|
if (sp->callback_func) {
|
2006-06-26 23:58:46 +00:00
|
|
|
sp->callback_func(sp->callback_data);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct pvr2_stream *pvr2_stream_create(void)
|
|
|
|
|
{
|
|
|
|
|
struct pvr2_stream *sp;
|
2016-12-22 19:25:39 +00:00
|
|
|
sp = kzalloc(sizeof(*sp), GFP_KERNEL);
|
2006-06-26 23:58:46 +00:00
|
|
|
if (!sp) return sp;
|
2016-12-22 19:25:39 +00:00
|
|
|
pvr2_trace(PVR2_TRACE_INIT, "pvr2_stream_create: sp=%p", sp);
|
2006-06-26 23:58:46 +00:00
|
|
|
pvr2_stream_init(sp);
|
|
|
|
|
return sp;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void pvr2_stream_destroy(struct pvr2_stream *sp)
|
|
|
|
|
{
|
|
|
|
|
if (!sp) return;
|
2016-12-22 19:25:39 +00:00
|
|
|
pvr2_trace(PVR2_TRACE_INIT, "pvr2_stream_destroy: sp=%p", sp);
|
2006-06-26 23:58:46 +00:00
|
|
|
pvr2_stream_done(sp);
|
|
|
|
|
kfree(sp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void pvr2_stream_setup(struct pvr2_stream *sp,
|
|
|
|
|
struct usb_device *dev,
|
|
|
|
|
int endpoint,
|
|
|
|
|
unsigned int tolerance)
|
|
|
|
|
{
|
|
|
|
|
mutex_lock(&sp->mutex); do {
|
|
|
|
|
pvr2_stream_internal_flush(sp);
|
|
|
|
|
sp->dev = dev;
|
|
|
|
|
sp->endpoint = endpoint;
|
|
|
|
|
sp->fail_tolerance = tolerance;
|
2016-12-22 19:25:39 +00:00
|
|
|
} while (0); mutex_unlock(&sp->mutex);
|
2006-06-26 23:58:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void pvr2_stream_set_callback(struct pvr2_stream *sp,
|
|
|
|
|
pvr2_stream_callback func,
|
|
|
|
|
void *data)
|
|
|
|
|
{
|
|
|
|
|
unsigned long irq_flags;
|
2015-04-29 18:14:40 +00:00
|
|
|
mutex_lock(&sp->mutex);
|
|
|
|
|
do {
|
2016-12-22 19:25:39 +00:00
|
|
|
spin_lock_irqsave(&sp->list_lock, irq_flags);
|
2006-06-26 23:58:46 +00:00
|
|
|
sp->callback_data = data;
|
|
|
|
|
sp->callback_func = func;
|
2016-12-22 19:25:39 +00:00
|
|
|
spin_unlock_irqrestore(&sp->list_lock, irq_flags);
|
|
|
|
|
} while (0);
|
2015-04-29 18:14:40 +00:00
|
|
|
mutex_unlock(&sp->mutex);
|
2006-06-26 23:58:46 +00:00
|
|
|
}
|
|
|
|
|
|
2008-03-28 08:34:45 +00:00
|
|
|
void pvr2_stream_get_stats(struct pvr2_stream *sp,
|
|
|
|
|
struct pvr2_stream_stats *stats,
|
|
|
|
|
int zero_counts)
|
|
|
|
|
{
|
|
|
|
|
unsigned long irq_flags;
|
2016-12-22 19:25:39 +00:00
|
|
|
spin_lock_irqsave(&sp->list_lock, irq_flags);
|
2008-03-28 08:34:45 +00:00
|
|
|
if (stats) {
|
|
|
|
|
stats->buffers_in_queue = sp->q_count;
|
|
|
|
|
stats->buffers_in_idle = sp->i_count;
|
|
|
|
|
stats->buffers_in_ready = sp->r_count;
|
|
|
|
|
stats->buffers_processed = sp->buffers_processed;
|
|
|
|
|
stats->buffers_failed = sp->buffers_failed;
|
|
|
|
|
stats->bytes_processed = sp->bytes_processed;
|
|
|
|
|
}
|
|
|
|
|
if (zero_counts) {
|
|
|
|
|
sp->buffers_processed = 0;
|
|
|
|
|
sp->buffers_failed = 0;
|
|
|
|
|
sp->bytes_processed = 0;
|
|
|
|
|
}
|
2016-12-22 19:25:39 +00:00
|
|
|
spin_unlock_irqrestore(&sp->list_lock, irq_flags);
|
2008-03-28 08:34:45 +00:00
|
|
|
}
|
|
|
|
|
|
2006-06-26 23:58:46 +00:00
|
|
|
/* Query / set the nominal buffer count */
|
2006-07-19 01:42:18 +00:00
|
|
|
int pvr2_stream_get_buffer_count(struct pvr2_stream *sp)
|
|
|
|
|
{
|
|
|
|
|
return sp->buffer_target_count;
|
|
|
|
|
}
|
2006-06-26 23:58:46 +00:00
|
|
|
|
2016-12-22 19:25:39 +00:00
|
|
|
int pvr2_stream_set_buffer_count(struct pvr2_stream *sp, unsigned int cnt)
|
2006-06-26 23:58:46 +00:00
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
if (sp->buffer_target_count == cnt) return 0;
|
2015-04-29 18:14:40 +00:00
|
|
|
mutex_lock(&sp->mutex);
|
|
|
|
|
do {
|
2006-06-26 23:58:46 +00:00
|
|
|
sp->buffer_target_count = cnt;
|
|
|
|
|
ret = pvr2_stream_achieve_buffer_count(sp);
|
2016-12-22 19:25:39 +00:00
|
|
|
} while (0);
|
2015-04-29 18:14:40 +00:00
|
|
|
mutex_unlock(&sp->mutex);
|
2006-06-26 23:58:46 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct pvr2_buffer *pvr2_stream_get_idle_buffer(struct pvr2_stream *sp)
|
|
|
|
|
{
|
|
|
|
|
struct list_head *lp = sp->idle_list.next;
|
2006-06-30 14:35:28 +00:00
|
|
|
if (lp == &sp->idle_list) return NULL;
|
2016-12-22 19:25:39 +00:00
|
|
|
return list_entry(lp, struct pvr2_buffer, list_overhead);
|
2006-06-26 23:58:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct pvr2_buffer *pvr2_stream_get_ready_buffer(struct pvr2_stream *sp)
|
|
|
|
|
{
|
|
|
|
|
struct list_head *lp = sp->ready_list.next;
|
2006-06-30 14:35:28 +00:00
|
|
|
if (lp == &sp->ready_list) return NULL;
|
2016-12-22 19:25:39 +00:00
|
|
|
return list_entry(lp, struct pvr2_buffer, list_overhead);
|
2006-06-26 23:58:46 +00:00
|
|
|
}
|
|
|
|
|
|
2016-12-22 19:25:39 +00:00
|
|
|
struct pvr2_buffer *pvr2_stream_get_buffer(struct pvr2_stream *sp, int id)
|
2006-06-26 23:58:46 +00:00
|
|
|
{
|
2006-06-30 14:35:28 +00:00
|
|
|
if (id < 0) return NULL;
|
|
|
|
|
if (id >= sp->buffer_total_count) return NULL;
|
2006-06-26 23:58:46 +00:00
|
|
|
return sp->buffers[id];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int pvr2_stream_get_ready_count(struct pvr2_stream *sp)
|
|
|
|
|
{
|
|
|
|
|
return sp->r_count;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void pvr2_stream_kill(struct pvr2_stream *sp)
|
|
|
|
|
{
|
|
|
|
|
struct pvr2_buffer *bp;
|
2015-04-29 18:14:40 +00:00
|
|
|
mutex_lock(&sp->mutex);
|
|
|
|
|
do {
|
2006-06-26 23:58:46 +00:00
|
|
|
pvr2_stream_internal_flush(sp);
|
2008-03-29 03:07:38 +00:00
|
|
|
while ((bp = pvr2_stream_get_ready_buffer(sp)) != NULL) {
|
2006-06-26 23:58:46 +00:00
|
|
|
pvr2_buffer_set_idle(bp);
|
|
|
|
|
}
|
|
|
|
|
if (sp->buffer_total_count != sp->buffer_target_count) {
|
|
|
|
|
pvr2_stream_achieve_buffer_count(sp);
|
|
|
|
|
}
|
2016-12-22 19:25:39 +00:00
|
|
|
} while (0);
|
2015-04-29 18:14:40 +00:00
|
|
|
mutex_unlock(&sp->mutex);
|
2006-06-26 23:58:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int pvr2_buffer_queue(struct pvr2_buffer *bp)
|
|
|
|
|
{
|
|
|
|
|
#undef SEED_BUFFER
|
|
|
|
|
#ifdef SEED_BUFFER
|
|
|
|
|
unsigned int idx;
|
|
|
|
|
unsigned int val;
|
|
|
|
|
#endif
|
|
|
|
|
int ret = 0;
|
|
|
|
|
struct pvr2_stream *sp;
|
|
|
|
|
if (!bp) return -EINVAL;
|
|
|
|
|
sp = bp->stream;
|
2015-04-29 18:14:40 +00:00
|
|
|
mutex_lock(&sp->mutex);
|
|
|
|
|
do {
|
2006-06-26 23:58:46 +00:00
|
|
|
pvr2_buffer_wipe(bp);
|
|
|
|
|
if (!sp->dev) {
|
|
|
|
|
ret = -EIO;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
pvr2_buffer_set_queued(bp);
|
|
|
|
|
#ifdef SEED_BUFFER
|
|
|
|
|
for (idx = 0; idx < (bp->max_count) / 4; idx++) {
|
|
|
|
|
val = bp->id << 24;
|
|
|
|
|
val |= idx;
|
|
|
|
|
((unsigned int *)(bp->ptr))[idx] = val;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
bp->status = -EINPROGRESS;
|
|
|
|
|
usb_fill_bulk_urb(bp->purb, // struct urb *urb
|
|
|
|
|
sp->dev, // struct usb_device *dev
|
|
|
|
|
// endpoint (below)
|
2016-12-22 19:25:39 +00:00
|
|
|
usb_rcvbulkpipe(sp->dev, sp->endpoint),
|
2006-06-26 23:58:46 +00:00
|
|
|
bp->ptr, // void *transfer_buffer
|
|
|
|
|
bp->max_count, // int buffer_length
|
|
|
|
|
buffer_complete,
|
|
|
|
|
bp);
|
2016-12-22 19:25:39 +00:00
|
|
|
usb_submit_urb(bp->purb, GFP_KERNEL);
|
|
|
|
|
} while (0);
|
2015-04-29 18:14:40 +00:00
|
|
|
mutex_unlock(&sp->mutex);
|
2006-06-26 23:58:46 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2016-12-22 19:25:39 +00:00
|
|
|
int pvr2_buffer_set_buffer(struct pvr2_buffer *bp, void *ptr, unsigned int cnt)
|
2006-06-26 23:58:46 +00:00
|
|
|
{
|
|
|
|
|
int ret = 0;
|
|
|
|
|
unsigned long irq_flags;
|
|
|
|
|
struct pvr2_stream *sp;
|
|
|
|
|
if (!bp) return -EINVAL;
|
|
|
|
|
sp = bp->stream;
|
2015-04-29 18:14:40 +00:00
|
|
|
mutex_lock(&sp->mutex);
|
|
|
|
|
do {
|
2016-12-22 19:25:39 +00:00
|
|
|
spin_lock_irqsave(&sp->list_lock, irq_flags);
|
2006-06-26 23:58:46 +00:00
|
|
|
if (bp->state != pvr2_buffer_state_idle) {
|
|
|
|
|
ret = -EPERM;
|
|
|
|
|
} else {
|
|
|
|
|
bp->ptr = ptr;
|
|
|
|
|
bp->stream->i_bcount -= bp->max_count;
|
|
|
|
|
bp->max_count = cnt;
|
|
|
|
|
bp->stream->i_bcount += bp->max_count;
|
|
|
|
|
pvr2_trace(PVR2_TRACE_BUF_FLOW,
|
[media] pvrusb2: don't break long lines
Due to the 80-cols restrictions, and latter due to checkpatch
warnings, several strings were broken into multiple lines. This
is not considered a good practice anymore, as it makes harder
to grep for strings at the source code.
As we're right now fixing other drivers due to KERN_CONT, we need
to be able to identify what printk strings don't end with a "\n".
It is a way easier to detect those if we don't break long lines.
So, join those continuation lines.
The patch was generated via the script below, and manually
adjusted if needed.
</script>
use Text::Tabs;
while (<>) {
if ($next ne "") {
$c=$_;
if ($c =~ /^\s+\"(.*)/) {
$c2=$1;
$next =~ s/\"\n$//;
$n = expand($next);
$funpos = index($n, '(');
$pos = index($c2, '",');
if ($funpos && $pos > 0) {
$s1 = substr $c2, 0, $pos + 2;
$s2 = ' ' x ($funpos + 1) . substr $c2, $pos + 2;
$s2 =~ s/^\s+//;
$s2 = ' ' x ($funpos + 1) . $s2 if ($s2 ne "");
print unexpand("$next$s1\n");
print unexpand("$s2\n") if ($s2 ne "");
} else {
print "$next$c2\n";
}
$next="";
next;
} else {
print $next;
}
$next="";
} else {
if (m/\"$/) {
if (!m/\\n\"$/) {
$next=$_;
next;
}
}
}
print $_;
}
</script>
Signed-off-by: Mauro Carvalho Chehab <mchehab@s-opensource.com>
2016-10-18 19:44:18 +00:00
|
|
|
"/*---TRACE_FLOW---*/ bufferPool %8s cap cap=%07d cnt=%02d",
|
2006-06-26 23:58:46 +00:00
|
|
|
pvr2_buffer_state_decode(
|
|
|
|
|
pvr2_buffer_state_idle),
|
2016-12-22 19:25:39 +00:00
|
|
|
bp->stream->i_bcount, bp->stream->i_count);
|
2006-06-26 23:58:46 +00:00
|
|
|
}
|
2016-12-22 19:25:39 +00:00
|
|
|
spin_unlock_irqrestore(&sp->list_lock, irq_flags);
|
|
|
|
|
} while (0);
|
2015-04-29 18:14:40 +00:00
|
|
|
mutex_unlock(&sp->mutex);
|
2006-06-26 23:58:46 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
unsigned int pvr2_buffer_get_count(struct pvr2_buffer *bp)
|
|
|
|
|
{
|
|
|
|
|
return bp->used_count;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int pvr2_buffer_get_status(struct pvr2_buffer *bp)
|
|
|
|
|
{
|
|
|
|
|
return bp->status;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int pvr2_buffer_get_id(struct pvr2_buffer *bp)
|
|
|
|
|
{
|
|
|
|
|
return bp->id;
|
|
|
|
|
}
|