forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1553 lines
41 KiB
1553 lines
41 KiB
// SPDX-License-Identifier: GPL-2.0-or-later |
|
/* |
|
* Driver for the NXP SAA7164 PCIe bridge |
|
* |
|
* Copyright (c) 2010-2015 Steven Toth <[email protected]> |
|
*/ |
|
|
|
#include <linux/init.h> |
|
#include <linux/list.h> |
|
#include <linux/module.h> |
|
#include <linux/moduleparam.h> |
|
#include <linux/kmod.h> |
|
#include <linux/kernel.h> |
|
#include <linux/slab.h> |
|
#include <linux/interrupt.h> |
|
#include <linux/debugfs.h> |
|
#include <linux/delay.h> |
|
#include <asm/div64.h> |
|
|
|
#include "saa7164.h" |
|
|
|
MODULE_DESCRIPTION("Driver for NXP SAA7164 based TV cards"); |
|
MODULE_AUTHOR("Steven Toth <[email protected]>"); |
|
MODULE_LICENSE("GPL"); |
|
|
|
/* |
|
* 1 Basic |
|
* 2 |
|
* 4 i2c |
|
* 8 api |
|
* 16 cmd |
|
* 32 bus |
|
*/ |
|
|
|
unsigned int saa_debug; |
|
module_param_named(debug, saa_debug, int, 0644); |
|
MODULE_PARM_DESC(debug, "enable debug messages"); |
|
|
|
static unsigned int fw_debug; |
|
module_param(fw_debug, int, 0644); |
|
MODULE_PARM_DESC(fw_debug, "Firmware debug level def:2"); |
|
|
|
unsigned int encoder_buffers = SAA7164_MAX_ENCODER_BUFFERS; |
|
module_param(encoder_buffers, int, 0644); |
|
MODULE_PARM_DESC(encoder_buffers, "Total buffers in read queue 16-512 def:64"); |
|
|
|
unsigned int vbi_buffers = SAA7164_MAX_VBI_BUFFERS; |
|
module_param(vbi_buffers, int, 0644); |
|
MODULE_PARM_DESC(vbi_buffers, "Total buffers in read queue 16-512 def:64"); |
|
|
|
unsigned int waitsecs = 10; |
|
module_param(waitsecs, int, 0644); |
|
MODULE_PARM_DESC(waitsecs, "timeout on firmware messages"); |
|
|
|
static unsigned int card[] = {[0 ... (SAA7164_MAXBOARDS - 1)] = UNSET }; |
|
module_param_array(card, int, NULL, 0444); |
|
MODULE_PARM_DESC(card, "card type"); |
|
|
|
static unsigned int print_histogram = 64; |
|
module_param(print_histogram, int, 0644); |
|
MODULE_PARM_DESC(print_histogram, "print histogram values once"); |
|
|
|
unsigned int crc_checking = 1; |
|
module_param(crc_checking, int, 0644); |
|
MODULE_PARM_DESC(crc_checking, "enable crc sanity checking on buffers"); |
|
|
|
static unsigned int guard_checking = 1; |
|
module_param(guard_checking, int, 0644); |
|
MODULE_PARM_DESC(guard_checking, |
|
"enable dma sanity checking for buffer overruns"); |
|
|
|
static bool enable_msi = true; |
|
module_param(enable_msi, bool, 0444); |
|
MODULE_PARM_DESC(enable_msi, |
|
"enable the use of an msi interrupt if available"); |
|
|
|
static unsigned int saa7164_devcount; |
|
|
|
static DEFINE_MUTEX(devlist); |
|
LIST_HEAD(saa7164_devlist); |
|
|
|
#define INT_SIZE 16 |
|
|
|
static void saa7164_pack_verifier(struct saa7164_buffer *buf) |
|
{ |
|
u8 *p = (u8 *)buf->cpu; |
|
int i; |
|
|
|
for (i = 0; i < buf->actual_size; i += 2048) { |
|
|
|
if ((*(p + i + 0) != 0x00) || (*(p + i + 1) != 0x00) || |
|
(*(p + i + 2) != 0x01) || (*(p + i + 3) != 0xBA)) { |
|
printk(KERN_ERR "No pack at 0x%x\n", i); |
|
#if 0 |
|
print_hex_dump(KERN_INFO, "", DUMP_PREFIX_OFFSET, 16, 1, |
|
p + 1, 32, false); |
|
#endif |
|
} |
|
} |
|
} |
|
|
|
#define FIXED_VIDEO_PID 0xf1 |
|
#define FIXED_AUDIO_PID 0xf2 |
|
|
|
static void saa7164_ts_verifier(struct saa7164_buffer *buf) |
|
{ |
|
struct saa7164_port *port = buf->port; |
|
u32 i; |
|
u8 cc, a; |
|
u16 pid; |
|
u8 *bufcpu = (u8 *)buf->cpu; |
|
|
|
port->sync_errors = 0; |
|
port->v_cc_errors = 0; |
|
port->a_cc_errors = 0; |
|
|
|
for (i = 0; i < buf->actual_size; i += 188) { |
|
if (*(bufcpu + i) != 0x47) |
|
port->sync_errors++; |
|
|
|
/* TODO: Query pid lower 8 bits, ignoring upper bits intensionally */ |
|
pid = ((*(bufcpu + i + 1) & 0x1f) << 8) | *(bufcpu + i + 2); |
|
cc = *(bufcpu + i + 3) & 0x0f; |
|
|
|
if (pid == FIXED_VIDEO_PID) { |
|
a = ((port->last_v_cc + 1) & 0x0f); |
|
if (a != cc) { |
|
printk(KERN_ERR "video cc last = %x current = %x i = %d\n", |
|
port->last_v_cc, cc, i); |
|
port->v_cc_errors++; |
|
} |
|
|
|
port->last_v_cc = cc; |
|
} else |
|
if (pid == FIXED_AUDIO_PID) { |
|
a = ((port->last_a_cc + 1) & 0x0f); |
|
if (a != cc) { |
|
printk(KERN_ERR "audio cc last = %x current = %x i = %d\n", |
|
port->last_a_cc, cc, i); |
|
port->a_cc_errors++; |
|
} |
|
|
|
port->last_a_cc = cc; |
|
} |
|
|
|
} |
|
|
|
/* Only report errors if we've been through this function at least |
|
* once already and the cached cc values are primed. First time through |
|
* always generates errors. |
|
*/ |
|
if (port->v_cc_errors && (port->done_first_interrupt > 1)) |
|
printk(KERN_ERR "video pid cc, %d errors\n", port->v_cc_errors); |
|
|
|
if (port->a_cc_errors && (port->done_first_interrupt > 1)) |
|
printk(KERN_ERR "audio pid cc, %d errors\n", port->a_cc_errors); |
|
|
|
if (port->sync_errors && (port->done_first_interrupt > 1)) |
|
printk(KERN_ERR "sync_errors = %d\n", port->sync_errors); |
|
|
|
if (port->done_first_interrupt == 1) |
|
port->done_first_interrupt++; |
|
} |
|
|
|
static void saa7164_histogram_reset(struct saa7164_histogram *hg, char *name) |
|
{ |
|
int i; |
|
|
|
memset(hg, 0, sizeof(struct saa7164_histogram)); |
|
strscpy(hg->name, name, sizeof(hg->name)); |
|
|
|
/* First 30ms x 1ms */ |
|
for (i = 0; i < 30; i++) |
|
hg->counter1[0 + i].val = i; |
|
|
|
/* 30 - 200ms x 10ms */ |
|
for (i = 0; i < 18; i++) |
|
hg->counter1[30 + i].val = 30 + (i * 10); |
|
|
|
/* 200 - 2000ms x 100ms */ |
|
for (i = 0; i < 15; i++) |
|
hg->counter1[48 + i].val = 200 + (i * 200); |
|
|
|
/* Catch all massive value (2secs) */ |
|
hg->counter1[55].val = 2000; |
|
|
|
/* Catch all massive value (4secs) */ |
|
hg->counter1[56].val = 4000; |
|
|
|
/* Catch all massive value (8secs) */ |
|
hg->counter1[57].val = 8000; |
|
|
|
/* Catch all massive value (15secs) */ |
|
hg->counter1[58].val = 15000; |
|
|
|
/* Catch all massive value (30secs) */ |
|
hg->counter1[59].val = 30000; |
|
|
|
/* Catch all massive value (60secs) */ |
|
hg->counter1[60].val = 60000; |
|
|
|
/* Catch all massive value (5mins) */ |
|
hg->counter1[61].val = 300000; |
|
|
|
/* Catch all massive value (15mins) */ |
|
hg->counter1[62].val = 900000; |
|
|
|
/* Catch all massive values (1hr) */ |
|
hg->counter1[63].val = 3600000; |
|
} |
|
|
|
void saa7164_histogram_update(struct saa7164_histogram *hg, u32 val) |
|
{ |
|
int i; |
|
for (i = 0; i < 64; i++) { |
|
if (val <= hg->counter1[i].val) { |
|
hg->counter1[i].count++; |
|
hg->counter1[i].update_time = jiffies; |
|
break; |
|
} |
|
} |
|
} |
|
|
|
static void saa7164_histogram_print(struct saa7164_port *port, |
|
struct saa7164_histogram *hg) |
|
{ |
|
u32 entries = 0; |
|
int i; |
|
|
|
printk(KERN_ERR "Histogram named %s (ms, count, last_update_jiffy)\n", hg->name); |
|
for (i = 0; i < 64; i++) { |
|
if (hg->counter1[i].count == 0) |
|
continue; |
|
|
|
printk(KERN_ERR " %4d %12d %Ld\n", |
|
hg->counter1[i].val, |
|
hg->counter1[i].count, |
|
hg->counter1[i].update_time); |
|
|
|
entries++; |
|
} |
|
printk(KERN_ERR "Total: %d\n", entries); |
|
} |
|
|
|
static void saa7164_work_enchandler_helper(struct saa7164_port *port, int bufnr) |
|
{ |
|
struct saa7164_dev *dev = port->dev; |
|
struct saa7164_buffer *buf = NULL; |
|
struct saa7164_user_buffer *ubuf = NULL; |
|
struct list_head *c, *n; |
|
int i = 0; |
|
u8 *p; |
|
|
|
mutex_lock(&port->dmaqueue_lock); |
|
list_for_each_safe(c, n, &port->dmaqueue.list) { |
|
|
|
buf = list_entry(c, struct saa7164_buffer, list); |
|
if (i++ > port->hwcfg.buffercount) { |
|
printk(KERN_ERR "%s() illegal i count %d\n", |
|
__func__, i); |
|
break; |
|
} |
|
|
|
if (buf->idx == bufnr) { |
|
|
|
/* Found the buffer, deal with it */ |
|
dprintk(DBGLVL_IRQ, "%s() bufnr: %d\n", __func__, bufnr); |
|
|
|
if (crc_checking) { |
|
/* Throw a new checksum on the dma buffer */ |
|
buf->crc = crc32(0, buf->cpu, buf->actual_size); |
|
} |
|
|
|
if (guard_checking) { |
|
p = (u8 *)buf->cpu; |
|
if ((*(p + buf->actual_size + 0) != 0xff) || |
|
(*(p + buf->actual_size + 1) != 0xff) || |
|
(*(p + buf->actual_size + 2) != 0xff) || |
|
(*(p + buf->actual_size + 3) != 0xff) || |
|
(*(p + buf->actual_size + 0x10) != 0xff) || |
|
(*(p + buf->actual_size + 0x11) != 0xff) || |
|
(*(p + buf->actual_size + 0x12) != 0xff) || |
|
(*(p + buf->actual_size + 0x13) != 0xff)) { |
|
printk(KERN_ERR "%s() buf %p guard buffer breach\n", |
|
__func__, buf); |
|
#if 0 |
|
print_hex_dump(KERN_INFO, "", DUMP_PREFIX_OFFSET, 16, 1, |
|
p + buf->actual_size - 32, 64, false); |
|
#endif |
|
} |
|
} |
|
|
|
if ((port->nr != SAA7164_PORT_VBI1) && (port->nr != SAA7164_PORT_VBI2)) { |
|
/* Validate the incoming buffer content */ |
|
if (port->encoder_params.stream_type == V4L2_MPEG_STREAM_TYPE_MPEG2_TS) |
|
saa7164_ts_verifier(buf); |
|
else if (port->encoder_params.stream_type == V4L2_MPEG_STREAM_TYPE_MPEG2_PS) |
|
saa7164_pack_verifier(buf); |
|
} |
|
|
|
/* find a free user buffer and clone to it */ |
|
if (!list_empty(&port->list_buf_free.list)) { |
|
|
|
/* Pull the first buffer from the used list */ |
|
ubuf = list_first_entry(&port->list_buf_free.list, |
|
struct saa7164_user_buffer, list); |
|
|
|
if (buf->actual_size <= ubuf->actual_size) { |
|
|
|
memcpy(ubuf->data, buf->cpu, ubuf->actual_size); |
|
|
|
if (crc_checking) { |
|
/* Throw a new checksum on the read buffer */ |
|
ubuf->crc = crc32(0, ubuf->data, ubuf->actual_size); |
|
} |
|
|
|
/* Requeue the buffer on the free list */ |
|
ubuf->pos = 0; |
|
|
|
list_move_tail(&ubuf->list, |
|
&port->list_buf_used.list); |
|
|
|
/* Flag any userland waiters */ |
|
wake_up_interruptible(&port->wait_read); |
|
|
|
} else { |
|
printk(KERN_ERR "buf %p bufsize fails match\n", buf); |
|
} |
|
|
|
} else |
|
printk(KERN_ERR "encirq no free buffers, increase param encoder_buffers\n"); |
|
|
|
/* Ensure offset into buffer remains 0, fill buffer |
|
* with known bad data. We check for this data at a later point |
|
* in time. */ |
|
saa7164_buffer_zero_offsets(port, bufnr); |
|
memset(buf->cpu, 0xff, buf->pci_size); |
|
if (crc_checking) { |
|
/* Throw yet aanother new checksum on the dma buffer */ |
|
buf->crc = crc32(0, buf->cpu, buf->actual_size); |
|
} |
|
|
|
break; |
|
} |
|
} |
|
mutex_unlock(&port->dmaqueue_lock); |
|
} |
|
|
|
static void saa7164_work_enchandler(struct work_struct *w) |
|
{ |
|
struct saa7164_port *port = |
|
container_of(w, struct saa7164_port, workenc); |
|
struct saa7164_dev *dev = port->dev; |
|
|
|
u32 wp, mcb, rp, cnt = 0; |
|
|
|
port->last_svc_msecs_diff = port->last_svc_msecs; |
|
port->last_svc_msecs = jiffies_to_msecs(jiffies); |
|
|
|
port->last_svc_msecs_diff = port->last_svc_msecs - |
|
port->last_svc_msecs_diff; |
|
|
|
saa7164_histogram_update(&port->svc_interval, |
|
port->last_svc_msecs_diff); |
|
|
|
port->last_irq_svc_msecs_diff = port->last_svc_msecs - |
|
port->last_irq_msecs; |
|
|
|
saa7164_histogram_update(&port->irq_svc_interval, |
|
port->last_irq_svc_msecs_diff); |
|
|
|
dprintk(DBGLVL_IRQ, |
|
"%s() %Ldms elapsed irq->deferred %Ldms wp: %d rp: %d\n", |
|
__func__, |
|
port->last_svc_msecs_diff, |
|
port->last_irq_svc_msecs_diff, |
|
port->last_svc_wp, |
|
port->last_svc_rp |
|
); |
|
|
|
/* Current write position */ |
|
wp = saa7164_readl(port->bufcounter); |
|
if (wp > (port->hwcfg.buffercount - 1)) { |
|
printk(KERN_ERR "%s() illegal buf count %d\n", __func__, wp); |
|
return; |
|
} |
|
|
|
/* Most current complete buffer */ |
|
if (wp == 0) |
|
mcb = (port->hwcfg.buffercount - 1); |
|
else |
|
mcb = wp - 1; |
|
|
|
while (1) { |
|
if (port->done_first_interrupt == 0) { |
|
port->done_first_interrupt++; |
|
rp = mcb; |
|
} else |
|
rp = (port->last_svc_rp + 1) % 8; |
|
|
|
if (rp > (port->hwcfg.buffercount - 1)) { |
|
printk(KERN_ERR "%s() illegal rp count %d\n", __func__, rp); |
|
break; |
|
} |
|
|
|
saa7164_work_enchandler_helper(port, rp); |
|
port->last_svc_rp = rp; |
|
cnt++; |
|
|
|
if (rp == mcb) |
|
break; |
|
} |
|
|
|
/* TODO: Convert this into a /proc/saa7164 style readable file */ |
|
if (print_histogram == port->nr) { |
|
saa7164_histogram_print(port, &port->irq_interval); |
|
saa7164_histogram_print(port, &port->svc_interval); |
|
saa7164_histogram_print(port, &port->irq_svc_interval); |
|
saa7164_histogram_print(port, &port->read_interval); |
|
saa7164_histogram_print(port, &port->poll_interval); |
|
/* TODO: fix this to preserve any previous state */ |
|
print_histogram = 64 + port->nr; |
|
} |
|
} |
|
|
|
static void saa7164_work_vbihandler(struct work_struct *w) |
|
{ |
|
struct saa7164_port *port = |
|
container_of(w, struct saa7164_port, workenc); |
|
struct saa7164_dev *dev = port->dev; |
|
|
|
u32 wp, mcb, rp, cnt = 0; |
|
|
|
port->last_svc_msecs_diff = port->last_svc_msecs; |
|
port->last_svc_msecs = jiffies_to_msecs(jiffies); |
|
port->last_svc_msecs_diff = port->last_svc_msecs - |
|
port->last_svc_msecs_diff; |
|
|
|
saa7164_histogram_update(&port->svc_interval, |
|
port->last_svc_msecs_diff); |
|
|
|
port->last_irq_svc_msecs_diff = port->last_svc_msecs - |
|
port->last_irq_msecs; |
|
|
|
saa7164_histogram_update(&port->irq_svc_interval, |
|
port->last_irq_svc_msecs_diff); |
|
|
|
dprintk(DBGLVL_IRQ, |
|
"%s() %Ldms elapsed irq->deferred %Ldms wp: %d rp: %d\n", |
|
__func__, |
|
port->last_svc_msecs_diff, |
|
port->last_irq_svc_msecs_diff, |
|
port->last_svc_wp, |
|
port->last_svc_rp |
|
); |
|
|
|
/* Current write position */ |
|
wp = saa7164_readl(port->bufcounter); |
|
if (wp > (port->hwcfg.buffercount - 1)) { |
|
printk(KERN_ERR "%s() illegal buf count %d\n", __func__, wp); |
|
return; |
|
} |
|
|
|
/* Most current complete buffer */ |
|
if (wp == 0) |
|
mcb = (port->hwcfg.buffercount - 1); |
|
else |
|
mcb = wp - 1; |
|
|
|
while (1) { |
|
if (port->done_first_interrupt == 0) { |
|
port->done_first_interrupt++; |
|
rp = mcb; |
|
} else |
|
rp = (port->last_svc_rp + 1) % 8; |
|
|
|
if (rp > (port->hwcfg.buffercount - 1)) { |
|
printk(KERN_ERR "%s() illegal rp count %d\n", __func__, rp); |
|
break; |
|
} |
|
|
|
saa7164_work_enchandler_helper(port, rp); |
|
port->last_svc_rp = rp; |
|
cnt++; |
|
|
|
if (rp == mcb) |
|
break; |
|
} |
|
|
|
/* TODO: Convert this into a /proc/saa7164 style readable file */ |
|
if (print_histogram == port->nr) { |
|
saa7164_histogram_print(port, &port->irq_interval); |
|
saa7164_histogram_print(port, &port->svc_interval); |
|
saa7164_histogram_print(port, &port->irq_svc_interval); |
|
saa7164_histogram_print(port, &port->read_interval); |
|
saa7164_histogram_print(port, &port->poll_interval); |
|
/* TODO: fix this to preserve any previous state */ |
|
print_histogram = 64 + port->nr; |
|
} |
|
} |
|
|
|
static void saa7164_work_cmdhandler(struct work_struct *w) |
|
{ |
|
struct saa7164_dev *dev = container_of(w, struct saa7164_dev, workcmd); |
|
|
|
/* Wake up any complete commands */ |
|
saa7164_irq_dequeue(dev); |
|
} |
|
|
|
static void saa7164_buffer_deliver(struct saa7164_buffer *buf) |
|
{ |
|
struct saa7164_port *port = buf->port; |
|
|
|
/* Feed the transport payload into the kernel demux */ |
|
dvb_dmx_swfilter_packets(&port->dvb.demux, (u8 *)buf->cpu, |
|
SAA7164_TS_NUMBER_OF_LINES); |
|
|
|
} |
|
|
|
static irqreturn_t saa7164_irq_vbi(struct saa7164_port *port) |
|
{ |
|
struct saa7164_dev *dev = port->dev; |
|
|
|
/* Store old time */ |
|
port->last_irq_msecs_diff = port->last_irq_msecs; |
|
|
|
/* Collect new stats */ |
|
port->last_irq_msecs = jiffies_to_msecs(jiffies); |
|
|
|
/* Calculate stats */ |
|
port->last_irq_msecs_diff = port->last_irq_msecs - |
|
port->last_irq_msecs_diff; |
|
|
|
saa7164_histogram_update(&port->irq_interval, |
|
port->last_irq_msecs_diff); |
|
|
|
dprintk(DBGLVL_IRQ, "%s() %Ldms elapsed\n", __func__, |
|
port->last_irq_msecs_diff); |
|
|
|
/* Tis calls the vbi irq handler */ |
|
schedule_work(&port->workenc); |
|
return 0; |
|
} |
|
|
|
static irqreturn_t saa7164_irq_encoder(struct saa7164_port *port) |
|
{ |
|
struct saa7164_dev *dev = port->dev; |
|
|
|
/* Store old time */ |
|
port->last_irq_msecs_diff = port->last_irq_msecs; |
|
|
|
/* Collect new stats */ |
|
port->last_irq_msecs = jiffies_to_msecs(jiffies); |
|
|
|
/* Calculate stats */ |
|
port->last_irq_msecs_diff = port->last_irq_msecs - |
|
port->last_irq_msecs_diff; |
|
|
|
saa7164_histogram_update(&port->irq_interval, |
|
port->last_irq_msecs_diff); |
|
|
|
dprintk(DBGLVL_IRQ, "%s() %Ldms elapsed\n", __func__, |
|
port->last_irq_msecs_diff); |
|
|
|
schedule_work(&port->workenc); |
|
return 0; |
|
} |
|
|
|
static irqreturn_t saa7164_irq_ts(struct saa7164_port *port) |
|
{ |
|
struct saa7164_dev *dev = port->dev; |
|
struct saa7164_buffer *buf; |
|
struct list_head *c, *n; |
|
int wp, i = 0, rp; |
|
|
|
/* Find the current write point from the hardware */ |
|
wp = saa7164_readl(port->bufcounter); |
|
|
|
BUG_ON(wp > (port->hwcfg.buffercount - 1)); |
|
|
|
/* Find the previous buffer to the current write point */ |
|
if (wp == 0) |
|
rp = (port->hwcfg.buffercount - 1); |
|
else |
|
rp = wp - 1; |
|
|
|
/* Lookup the WP in the buffer list */ |
|
/* TODO: turn this into a worker thread */ |
|
list_for_each_safe(c, n, &port->dmaqueue.list) { |
|
buf = list_entry(c, struct saa7164_buffer, list); |
|
BUG_ON(i > port->hwcfg.buffercount); |
|
i++; |
|
|
|
if (buf->idx == rp) { |
|
/* Found the buffer, deal with it */ |
|
dprintk(DBGLVL_IRQ, "%s() wp: %d processing: %d\n", |
|
__func__, wp, rp); |
|
saa7164_buffer_deliver(buf); |
|
break; |
|
} |
|
|
|
} |
|
return 0; |
|
} |
|
|
|
/* Primary IRQ handler and dispatch mechanism */ |
|
static irqreturn_t saa7164_irq(int irq, void *dev_id) |
|
{ |
|
struct saa7164_dev *dev = dev_id; |
|
struct saa7164_port *porta, *portb, *portc, *portd, *porte, *portf; |
|
|
|
u32 intid, intstat[INT_SIZE/4]; |
|
int i, handled = 0, bit; |
|
|
|
if (dev == NULL) { |
|
printk(KERN_ERR "%s() No device specified\n", __func__); |
|
handled = 0; |
|
goto out; |
|
} |
|
|
|
porta = &dev->ports[SAA7164_PORT_TS1]; |
|
portb = &dev->ports[SAA7164_PORT_TS2]; |
|
portc = &dev->ports[SAA7164_PORT_ENC1]; |
|
portd = &dev->ports[SAA7164_PORT_ENC2]; |
|
porte = &dev->ports[SAA7164_PORT_VBI1]; |
|
portf = &dev->ports[SAA7164_PORT_VBI2]; |
|
|
|
/* Check that the hardware is accessible. If the status bytes are |
|
* 0xFF then the device is not accessible, the the IRQ belongs |
|
* to another driver. |
|
* 4 x u32 interrupt registers. |
|
*/ |
|
for (i = 0; i < INT_SIZE/4; i++) { |
|
|
|
/* TODO: Convert into saa7164_readl() */ |
|
/* Read the 4 hardware interrupt registers */ |
|
intstat[i] = saa7164_readl(dev->int_status + (i * 4)); |
|
|
|
if (intstat[i]) |
|
handled = 1; |
|
} |
|
if (handled == 0) |
|
goto out; |
|
|
|
/* For each of the HW interrupt registers */ |
|
for (i = 0; i < INT_SIZE/4; i++) { |
|
|
|
if (intstat[i]) { |
|
/* Each function of the board has it's own interruptid. |
|
* Find the function that triggered then call |
|
* it's handler. |
|
*/ |
|
for (bit = 0; bit < 32; bit++) { |
|
|
|
if (((intstat[i] >> bit) & 0x00000001) == 0) |
|
continue; |
|
|
|
/* Calculate the interrupt id (0x00 to 0x7f) */ |
|
|
|
intid = (i * 32) + bit; |
|
if (intid == dev->intfdesc.bInterruptId) { |
|
/* A response to an cmd/api call */ |
|
schedule_work(&dev->workcmd); |
|
} else if (intid == porta->hwcfg.interruptid) { |
|
|
|
/* Transport path 1 */ |
|
saa7164_irq_ts(porta); |
|
|
|
} else if (intid == portb->hwcfg.interruptid) { |
|
|
|
/* Transport path 2 */ |
|
saa7164_irq_ts(portb); |
|
|
|
} else if (intid == portc->hwcfg.interruptid) { |
|
|
|
/* Encoder path 1 */ |
|
saa7164_irq_encoder(portc); |
|
|
|
} else if (intid == portd->hwcfg.interruptid) { |
|
|
|
/* Encoder path 2 */ |
|
saa7164_irq_encoder(portd); |
|
|
|
} else if (intid == porte->hwcfg.interruptid) { |
|
|
|
/* VBI path 1 */ |
|
saa7164_irq_vbi(porte); |
|
|
|
} else if (intid == portf->hwcfg.interruptid) { |
|
|
|
/* VBI path 2 */ |
|
saa7164_irq_vbi(portf); |
|
|
|
} else { |
|
/* Find the function */ |
|
dprintk(DBGLVL_IRQ, |
|
"%s() unhandled interrupt reg 0x%x bit 0x%x intid = 0x%x\n", |
|
__func__, i, bit, intid); |
|
} |
|
} |
|
|
|
/* Ack it */ |
|
saa7164_writel(dev->int_ack + (i * 4), intstat[i]); |
|
|
|
} |
|
} |
|
out: |
|
return IRQ_RETVAL(handled); |
|
} |
|
|
|
void saa7164_getfirmwarestatus(struct saa7164_dev *dev) |
|
{ |
|
struct saa7164_fw_status *s = &dev->fw_status; |
|
|
|
dev->fw_status.status = saa7164_readl(SAA_DEVICE_SYSINIT_STATUS); |
|
dev->fw_status.mode = saa7164_readl(SAA_DEVICE_SYSINIT_MODE); |
|
dev->fw_status.spec = saa7164_readl(SAA_DEVICE_SYSINIT_SPEC); |
|
dev->fw_status.inst = saa7164_readl(SAA_DEVICE_SYSINIT_INST); |
|
dev->fw_status.cpuload = saa7164_readl(SAA_DEVICE_SYSINIT_CPULOAD); |
|
dev->fw_status.remainheap = |
|
saa7164_readl(SAA_DEVICE_SYSINIT_REMAINHEAP); |
|
|
|
dprintk(1, "Firmware status:\n"); |
|
dprintk(1, " .status = 0x%08x\n", s->status); |
|
dprintk(1, " .mode = 0x%08x\n", s->mode); |
|
dprintk(1, " .spec = 0x%08x\n", s->spec); |
|
dprintk(1, " .inst = 0x%08x\n", s->inst); |
|
dprintk(1, " .cpuload = 0x%08x\n", s->cpuload); |
|
dprintk(1, " .remainheap = 0x%08x\n", s->remainheap); |
|
} |
|
|
|
u32 saa7164_getcurrentfirmwareversion(struct saa7164_dev *dev) |
|
{ |
|
u32 reg; |
|
|
|
reg = saa7164_readl(SAA_DEVICE_VERSION); |
|
dprintk(1, "Device running firmware version %d.%d.%d.%d (0x%x)\n", |
|
(reg & 0x0000fc00) >> 10, |
|
(reg & 0x000003e0) >> 5, |
|
(reg & 0x0000001f), |
|
(reg & 0xffff0000) >> 16, |
|
reg); |
|
|
|
return reg; |
|
} |
|
|
|
/* TODO: Debugging func, remove */ |
|
void saa7164_dumpregs(struct saa7164_dev *dev, u32 addr) |
|
{ |
|
int i; |
|
|
|
dprintk(1, "--------------------> 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f\n"); |
|
|
|
for (i = 0; i < 0x100; i += 16) |
|
dprintk(1, "region0[0x%08x] = %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n", |
|
i, |
|
(u8)saa7164_readb(addr + i + 0), |
|
(u8)saa7164_readb(addr + i + 1), |
|
(u8)saa7164_readb(addr + i + 2), |
|
(u8)saa7164_readb(addr + i + 3), |
|
(u8)saa7164_readb(addr + i + 4), |
|
(u8)saa7164_readb(addr + i + 5), |
|
(u8)saa7164_readb(addr + i + 6), |
|
(u8)saa7164_readb(addr + i + 7), |
|
(u8)saa7164_readb(addr + i + 8), |
|
(u8)saa7164_readb(addr + i + 9), |
|
(u8)saa7164_readb(addr + i + 10), |
|
(u8)saa7164_readb(addr + i + 11), |
|
(u8)saa7164_readb(addr + i + 12), |
|
(u8)saa7164_readb(addr + i + 13), |
|
(u8)saa7164_readb(addr + i + 14), |
|
(u8)saa7164_readb(addr + i + 15) |
|
); |
|
} |
|
|
|
static void saa7164_dump_hwdesc(struct saa7164_dev *dev) |
|
{ |
|
dprintk(1, "@0x%p hwdesc sizeof(struct tmComResHWDescr) = %d bytes\n", |
|
&dev->hwdesc, (u32)sizeof(struct tmComResHWDescr)); |
|
|
|
dprintk(1, " .bLength = 0x%x\n", dev->hwdesc.bLength); |
|
dprintk(1, " .bDescriptorType = 0x%x\n", dev->hwdesc.bDescriptorType); |
|
dprintk(1, " .bDescriptorSubtype = 0x%x\n", |
|
dev->hwdesc.bDescriptorSubtype); |
|
|
|
dprintk(1, " .bcdSpecVersion = 0x%x\n", dev->hwdesc.bcdSpecVersion); |
|
dprintk(1, " .dwClockFrequency = 0x%x\n", dev->hwdesc.dwClockFrequency); |
|
dprintk(1, " .dwClockUpdateRes = 0x%x\n", dev->hwdesc.dwClockUpdateRes); |
|
dprintk(1, " .bCapabilities = 0x%x\n", dev->hwdesc.bCapabilities); |
|
dprintk(1, " .dwDeviceRegistersLocation = 0x%x\n", |
|
dev->hwdesc.dwDeviceRegistersLocation); |
|
|
|
dprintk(1, " .dwHostMemoryRegion = 0x%x\n", |
|
dev->hwdesc.dwHostMemoryRegion); |
|
|
|
dprintk(1, " .dwHostMemoryRegionSize = 0x%x\n", |
|
dev->hwdesc.dwHostMemoryRegionSize); |
|
|
|
dprintk(1, " .dwHostHibernatMemRegion = 0x%x\n", |
|
dev->hwdesc.dwHostHibernatMemRegion); |
|
|
|
dprintk(1, " .dwHostHibernatMemRegionSize = 0x%x\n", |
|
dev->hwdesc.dwHostHibernatMemRegionSize); |
|
} |
|
|
|
static void saa7164_dump_intfdesc(struct saa7164_dev *dev) |
|
{ |
|
dprintk(1, "@0x%p intfdesc sizeof(struct tmComResInterfaceDescr) = %d bytes\n", |
|
&dev->intfdesc, (u32)sizeof(struct tmComResInterfaceDescr)); |
|
|
|
dprintk(1, " .bLength = 0x%x\n", dev->intfdesc.bLength); |
|
dprintk(1, " .bDescriptorType = 0x%x\n", dev->intfdesc.bDescriptorType); |
|
dprintk(1, " .bDescriptorSubtype = 0x%x\n", |
|
dev->intfdesc.bDescriptorSubtype); |
|
|
|
dprintk(1, " .bFlags = 0x%x\n", dev->intfdesc.bFlags); |
|
dprintk(1, " .bInterfaceType = 0x%x\n", dev->intfdesc.bInterfaceType); |
|
dprintk(1, " .bInterfaceId = 0x%x\n", dev->intfdesc.bInterfaceId); |
|
dprintk(1, " .bBaseInterface = 0x%x\n", dev->intfdesc.bBaseInterface); |
|
dprintk(1, " .bInterruptId = 0x%x\n", dev->intfdesc.bInterruptId); |
|
dprintk(1, " .bDebugInterruptId = 0x%x\n", |
|
dev->intfdesc.bDebugInterruptId); |
|
|
|
dprintk(1, " .BARLocation = 0x%x\n", dev->intfdesc.BARLocation); |
|
} |
|
|
|
static void saa7164_dump_busdesc(struct saa7164_dev *dev) |
|
{ |
|
dprintk(1, "@0x%p busdesc sizeof(struct tmComResBusDescr) = %d bytes\n", |
|
&dev->busdesc, (u32)sizeof(struct tmComResBusDescr)); |
|
|
|
dprintk(1, " .CommandRing = 0x%016Lx\n", dev->busdesc.CommandRing); |
|
dprintk(1, " .ResponseRing = 0x%016Lx\n", dev->busdesc.ResponseRing); |
|
dprintk(1, " .CommandWrite = 0x%x\n", dev->busdesc.CommandWrite); |
|
dprintk(1, " .CommandRead = 0x%x\n", dev->busdesc.CommandRead); |
|
dprintk(1, " .ResponseWrite = 0x%x\n", dev->busdesc.ResponseWrite); |
|
dprintk(1, " .ResponseRead = 0x%x\n", dev->busdesc.ResponseRead); |
|
} |
|
|
|
/* Much of the hardware configuration and PCI registers are configured |
|
* dynamically depending on firmware. We have to cache some initial |
|
* structures then use these to locate other important structures |
|
* from PCI space. |
|
*/ |
|
static void saa7164_get_descriptors(struct saa7164_dev *dev) |
|
{ |
|
memcpy_fromio(&dev->hwdesc, dev->bmmio, sizeof(struct tmComResHWDescr)); |
|
memcpy_fromio(&dev->intfdesc, dev->bmmio + sizeof(struct tmComResHWDescr), |
|
sizeof(struct tmComResInterfaceDescr)); |
|
memcpy_fromio(&dev->busdesc, dev->bmmio + dev->intfdesc.BARLocation, |
|
sizeof(struct tmComResBusDescr)); |
|
|
|
if (dev->hwdesc.bLength != sizeof(struct tmComResHWDescr)) { |
|
printk(KERN_ERR "Structure struct tmComResHWDescr is mangled\n"); |
|
printk(KERN_ERR "Need %x got %d\n", dev->hwdesc.bLength, |
|
(u32)sizeof(struct tmComResHWDescr)); |
|
} else |
|
saa7164_dump_hwdesc(dev); |
|
|
|
if (dev->intfdesc.bLength != sizeof(struct tmComResInterfaceDescr)) { |
|
printk(KERN_ERR "struct struct tmComResInterfaceDescr is mangled\n"); |
|
printk(KERN_ERR "Need %x got %d\n", dev->intfdesc.bLength, |
|
(u32)sizeof(struct tmComResInterfaceDescr)); |
|
} else |
|
saa7164_dump_intfdesc(dev); |
|
|
|
saa7164_dump_busdesc(dev); |
|
} |
|
|
|
static int saa7164_pci_quirks(struct saa7164_dev *dev) |
|
{ |
|
return 0; |
|
} |
|
|
|
static int get_resources(struct saa7164_dev *dev) |
|
{ |
|
if (request_mem_region(pci_resource_start(dev->pci, 0), |
|
pci_resource_len(dev->pci, 0), dev->name)) { |
|
|
|
if (request_mem_region(pci_resource_start(dev->pci, 2), |
|
pci_resource_len(dev->pci, 2), dev->name)) |
|
return 0; |
|
} |
|
|
|
printk(KERN_ERR "%s: can't get MMIO memory @ 0x%llx or 0x%llx\n", |
|
dev->name, |
|
(u64)pci_resource_start(dev->pci, 0), |
|
(u64)pci_resource_start(dev->pci, 2)); |
|
|
|
return -EBUSY; |
|
} |
|
|
|
static int saa7164_port_init(struct saa7164_dev *dev, int portnr) |
|
{ |
|
struct saa7164_port *port = NULL; |
|
|
|
BUG_ON((portnr < 0) || (portnr >= SAA7164_MAX_PORTS)); |
|
|
|
port = &dev->ports[portnr]; |
|
|
|
port->dev = dev; |
|
port->nr = portnr; |
|
|
|
if ((portnr == SAA7164_PORT_TS1) || (portnr == SAA7164_PORT_TS2)) |
|
port->type = SAA7164_MPEG_DVB; |
|
else |
|
if ((portnr == SAA7164_PORT_ENC1) || (portnr == SAA7164_PORT_ENC2)) { |
|
port->type = SAA7164_MPEG_ENCODER; |
|
|
|
/* We need a deferred interrupt handler for cmd handling */ |
|
INIT_WORK(&port->workenc, saa7164_work_enchandler); |
|
} else if ((portnr == SAA7164_PORT_VBI1) || (portnr == SAA7164_PORT_VBI2)) { |
|
port->type = SAA7164_MPEG_VBI; |
|
|
|
/* We need a deferred interrupt handler for cmd handling */ |
|
INIT_WORK(&port->workenc, saa7164_work_vbihandler); |
|
} else |
|
BUG(); |
|
|
|
/* Init all the critical resources */ |
|
mutex_init(&port->dvb.lock); |
|
INIT_LIST_HEAD(&port->dmaqueue.list); |
|
mutex_init(&port->dmaqueue_lock); |
|
|
|
INIT_LIST_HEAD(&port->list_buf_used.list); |
|
INIT_LIST_HEAD(&port->list_buf_free.list); |
|
init_waitqueue_head(&port->wait_read); |
|
|
|
|
|
saa7164_histogram_reset(&port->irq_interval, "irq intervals"); |
|
saa7164_histogram_reset(&port->svc_interval, "deferred intervals"); |
|
saa7164_histogram_reset(&port->irq_svc_interval, |
|
"irq to deferred intervals"); |
|
saa7164_histogram_reset(&port->read_interval, |
|
"encoder/vbi read() intervals"); |
|
saa7164_histogram_reset(&port->poll_interval, |
|
"encoder/vbi poll() intervals"); |
|
|
|
return 0; |
|
} |
|
|
|
static int saa7164_dev_setup(struct saa7164_dev *dev) |
|
{ |
|
int i; |
|
|
|
mutex_init(&dev->lock); |
|
atomic_inc(&dev->refcount); |
|
dev->nr = saa7164_devcount++; |
|
|
|
snprintf(dev->name, sizeof(dev->name), "saa7164[%d]", dev->nr); |
|
|
|
mutex_lock(&devlist); |
|
list_add_tail(&dev->devlist, &saa7164_devlist); |
|
mutex_unlock(&devlist); |
|
|
|
/* board config */ |
|
dev->board = UNSET; |
|
if (card[dev->nr] < saa7164_bcount) |
|
dev->board = card[dev->nr]; |
|
|
|
for (i = 0; UNSET == dev->board && i < saa7164_idcount; i++) |
|
if (dev->pci->subsystem_vendor == saa7164_subids[i].subvendor && |
|
dev->pci->subsystem_device == |
|
saa7164_subids[i].subdevice) |
|
dev->board = saa7164_subids[i].card; |
|
|
|
if (UNSET == dev->board) { |
|
dev->board = SAA7164_BOARD_UNKNOWN; |
|
saa7164_card_list(dev); |
|
} |
|
|
|
dev->pci_bus = dev->pci->bus->number; |
|
dev->pci_slot = PCI_SLOT(dev->pci->devfn); |
|
|
|
/* I2C Defaults / setup */ |
|
dev->i2c_bus[0].dev = dev; |
|
dev->i2c_bus[0].nr = 0; |
|
dev->i2c_bus[1].dev = dev; |
|
dev->i2c_bus[1].nr = 1; |
|
dev->i2c_bus[2].dev = dev; |
|
dev->i2c_bus[2].nr = 2; |
|
|
|
/* Transport + Encoder ports 1, 2, 3, 4 - Defaults / setup */ |
|
saa7164_port_init(dev, SAA7164_PORT_TS1); |
|
saa7164_port_init(dev, SAA7164_PORT_TS2); |
|
saa7164_port_init(dev, SAA7164_PORT_ENC1); |
|
saa7164_port_init(dev, SAA7164_PORT_ENC2); |
|
saa7164_port_init(dev, SAA7164_PORT_VBI1); |
|
saa7164_port_init(dev, SAA7164_PORT_VBI2); |
|
|
|
if (get_resources(dev) < 0) { |
|
printk(KERN_ERR "CORE %s No more PCIe resources for subsystem: %04x:%04x\n", |
|
dev->name, dev->pci->subsystem_vendor, |
|
dev->pci->subsystem_device); |
|
|
|
saa7164_devcount--; |
|
return -ENODEV; |
|
} |
|
|
|
/* PCI/e allocations */ |
|
dev->lmmio = ioremap(pci_resource_start(dev->pci, 0), |
|
pci_resource_len(dev->pci, 0)); |
|
|
|
dev->lmmio2 = ioremap(pci_resource_start(dev->pci, 2), |
|
pci_resource_len(dev->pci, 2)); |
|
|
|
dev->bmmio = (u8 __iomem *)dev->lmmio; |
|
dev->bmmio2 = (u8 __iomem *)dev->lmmio2; |
|
|
|
/* Interrupt and ack register locations offset of bmmio */ |
|
dev->int_status = 0x183000 + 0xf80; |
|
dev->int_ack = 0x183000 + 0xf90; |
|
|
|
printk(KERN_INFO |
|
"CORE %s: subsystem: %04x:%04x, board: %s [card=%d,%s]\n", |
|
dev->name, dev->pci->subsystem_vendor, |
|
dev->pci->subsystem_device, saa7164_boards[dev->board].name, |
|
dev->board, card[dev->nr] == dev->board ? |
|
"insmod option" : "autodetected"); |
|
|
|
saa7164_pci_quirks(dev); |
|
|
|
return 0; |
|
} |
|
|
|
static void saa7164_dev_unregister(struct saa7164_dev *dev) |
|
{ |
|
dprintk(1, "%s()\n", __func__); |
|
|
|
release_mem_region(pci_resource_start(dev->pci, 0), |
|
pci_resource_len(dev->pci, 0)); |
|
|
|
release_mem_region(pci_resource_start(dev->pci, 2), |
|
pci_resource_len(dev->pci, 2)); |
|
|
|
if (!atomic_dec_and_test(&dev->refcount)) |
|
return; |
|
|
|
iounmap(dev->lmmio); |
|
iounmap(dev->lmmio2); |
|
|
|
return; |
|
} |
|
|
|
#ifdef CONFIG_DEBUG_FS |
|
static void *saa7164_seq_start(struct seq_file *s, loff_t *pos) |
|
{ |
|
struct saa7164_dev *dev; |
|
loff_t index = *pos; |
|
|
|
mutex_lock(&devlist); |
|
list_for_each_entry(dev, &saa7164_devlist, devlist) { |
|
if (index-- == 0) { |
|
mutex_unlock(&devlist); |
|
return dev; |
|
} |
|
} |
|
mutex_unlock(&devlist); |
|
|
|
return NULL; |
|
} |
|
|
|
static void *saa7164_seq_next(struct seq_file *s, void *v, loff_t *pos) |
|
{ |
|
struct saa7164_dev *dev = v; |
|
void *ret; |
|
|
|
mutex_lock(&devlist); |
|
if (list_is_last(&dev->devlist, &saa7164_devlist)) |
|
ret = NULL; |
|
else |
|
ret = list_next_entry(dev, devlist); |
|
mutex_unlock(&devlist); |
|
|
|
++*pos; |
|
|
|
return ret; |
|
} |
|
|
|
static void saa7164_seq_stop(struct seq_file *s, void *v) |
|
{ |
|
} |
|
|
|
static int saa7164_seq_show(struct seq_file *m, void *v) |
|
{ |
|
struct saa7164_dev *dev = v; |
|
struct tmComResBusInfo *b; |
|
int i, c; |
|
|
|
seq_printf(m, "%s = %p\n", dev->name, dev); |
|
|
|
/* Lock the bus from any other access */ |
|
b = &dev->bus; |
|
mutex_lock(&b->lock); |
|
|
|
seq_printf(m, " .m_pdwSetWritePos = 0x%x (0x%08x)\n", |
|
b->m_dwSetReadPos, saa7164_readl(b->m_dwSetReadPos)); |
|
|
|
seq_printf(m, " .m_pdwSetReadPos = 0x%x (0x%08x)\n", |
|
b->m_dwSetWritePos, saa7164_readl(b->m_dwSetWritePos)); |
|
|
|
seq_printf(m, " .m_pdwGetWritePos = 0x%x (0x%08x)\n", |
|
b->m_dwGetReadPos, saa7164_readl(b->m_dwGetReadPos)); |
|
|
|
seq_printf(m, " .m_pdwGetReadPos = 0x%x (0x%08x)\n", |
|
b->m_dwGetWritePos, saa7164_readl(b->m_dwGetWritePos)); |
|
c = 0; |
|
seq_puts(m, "\n Set Ring:\n"); |
|
seq_puts(m, "\n addr 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f\n"); |
|
for (i = 0; i < b->m_dwSizeSetRing; i++) { |
|
if (c == 0) |
|
seq_printf(m, " %04x:", i); |
|
|
|
seq_printf(m, " %02x", readb(b->m_pdwSetRing + i)); |
|
|
|
if (++c == 16) { |
|
seq_puts(m, "\n"); |
|
c = 0; |
|
} |
|
} |
|
|
|
c = 0; |
|
seq_puts(m, "\n Get Ring:\n"); |
|
seq_puts(m, "\n addr 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f\n"); |
|
for (i = 0; i < b->m_dwSizeGetRing; i++) { |
|
if (c == 0) |
|
seq_printf(m, " %04x:", i); |
|
|
|
seq_printf(m, " %02x", readb(b->m_pdwGetRing + i)); |
|
|
|
if (++c == 16) { |
|
seq_puts(m, "\n"); |
|
c = 0; |
|
} |
|
} |
|
|
|
mutex_unlock(&b->lock); |
|
|
|
return 0; |
|
} |
|
|
|
static const struct seq_operations saa7164_sops = { |
|
.start = saa7164_seq_start, |
|
.next = saa7164_seq_next, |
|
.stop = saa7164_seq_stop, |
|
.show = saa7164_seq_show, |
|
}; |
|
|
|
DEFINE_SEQ_ATTRIBUTE(saa7164); |
|
|
|
static struct dentry *saa7614_dentry; |
|
|
|
static void __init saa7164_debugfs_create(void) |
|
{ |
|
saa7614_dentry = debugfs_create_file("saa7164", 0444, NULL, NULL, |
|
&saa7164_fops); |
|
} |
|
|
|
static void __exit saa7164_debugfs_remove(void) |
|
{ |
|
debugfs_remove(saa7614_dentry); |
|
} |
|
#else |
|
static void saa7164_debugfs_create(void) { } |
|
static void saa7164_debugfs_remove(void) { } |
|
#endif |
|
|
|
static int saa7164_thread_function(void *data) |
|
{ |
|
struct saa7164_dev *dev = data; |
|
struct tmFwInfoStruct fwinfo; |
|
u64 last_poll_time = 0; |
|
|
|
dprintk(DBGLVL_THR, "thread started\n"); |
|
|
|
set_freezable(); |
|
|
|
while (1) { |
|
msleep_interruptible(100); |
|
if (kthread_should_stop()) |
|
break; |
|
try_to_freeze(); |
|
|
|
dprintk(DBGLVL_THR, "thread running\n"); |
|
|
|
/* Dump the firmware debug message to console */ |
|
/* Polling this costs us 1-2% of the arm CPU */ |
|
/* convert this into a respnde to interrupt 0x7a */ |
|
saa7164_api_collect_debug(dev); |
|
|
|
/* Monitor CPU load every 1 second */ |
|
if ((last_poll_time + 1000 /* ms */) < jiffies_to_msecs(jiffies)) { |
|
saa7164_api_get_load_info(dev, &fwinfo); |
|
last_poll_time = jiffies_to_msecs(jiffies); |
|
} |
|
|
|
} |
|
|
|
dprintk(DBGLVL_THR, "thread exiting\n"); |
|
return 0; |
|
} |
|
|
|
static bool saa7164_enable_msi(struct pci_dev *pci_dev, struct saa7164_dev *dev) |
|
{ |
|
int err; |
|
|
|
if (!enable_msi) { |
|
printk(KERN_WARNING "%s() MSI disabled by module parameter 'enable_msi'" |
|
, __func__); |
|
return false; |
|
} |
|
|
|
err = pci_enable_msi(pci_dev); |
|
|
|
if (err) { |
|
printk(KERN_ERR "%s() Failed to enable MSI interrupt. Falling back to a shared IRQ\n", |
|
__func__); |
|
return false; |
|
} |
|
|
|
/* no error - so request an msi interrupt */ |
|
err = request_irq(pci_dev->irq, saa7164_irq, 0, |
|
dev->name, dev); |
|
|
|
if (err) { |
|
/* fall back to legacy interrupt */ |
|
printk(KERN_ERR "%s() Failed to get an MSI interrupt. Falling back to a shared IRQ\n", |
|
__func__); |
|
pci_disable_msi(pci_dev); |
|
return false; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
static int saa7164_initdev(struct pci_dev *pci_dev, |
|
const struct pci_device_id *pci_id) |
|
{ |
|
struct saa7164_dev *dev; |
|
int err, i; |
|
u32 version; |
|
|
|
dev = kzalloc(sizeof(*dev), GFP_KERNEL); |
|
if (NULL == dev) |
|
return -ENOMEM; |
|
|
|
err = v4l2_device_register(&pci_dev->dev, &dev->v4l2_dev); |
|
if (err < 0) { |
|
dev_err(&pci_dev->dev, "v4l2_device_register failed\n"); |
|
goto fail_free; |
|
} |
|
|
|
/* pci init */ |
|
dev->pci = pci_dev; |
|
if (pci_enable_device(pci_dev)) { |
|
err = -EIO; |
|
goto fail_free; |
|
} |
|
|
|
if (saa7164_dev_setup(dev) < 0) { |
|
err = -EINVAL; |
|
goto fail_free; |
|
} |
|
|
|
/* print pci info */ |
|
dev->pci_rev = pci_dev->revision; |
|
pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &dev->pci_lat); |
|
printk(KERN_INFO "%s/0: found at %s, rev: %d, irq: %d, latency: %d, mmio: 0x%llx\n", |
|
dev->name, |
|
pci_name(pci_dev), dev->pci_rev, pci_dev->irq, |
|
dev->pci_lat, |
|
(unsigned long long)pci_resource_start(pci_dev, 0)); |
|
|
|
pci_set_master(pci_dev); |
|
/* TODO */ |
|
err = dma_set_mask(&pci_dev->dev, 0xffffffff); |
|
if (err) { |
|
printk("%s/0: Oops: no 32bit PCI DMA ???\n", dev->name); |
|
goto fail_irq; |
|
} |
|
|
|
/* irq bit */ |
|
if (saa7164_enable_msi(pci_dev, dev)) { |
|
dev->msi = true; |
|
} else { |
|
/* if we have an error (i.e. we don't have an interrupt) |
|
or msi is not enabled - fallback to shared interrupt */ |
|
|
|
err = request_irq(pci_dev->irq, saa7164_irq, |
|
IRQF_SHARED, dev->name, dev); |
|
|
|
if (err < 0) { |
|
printk(KERN_ERR "%s: can't get IRQ %d\n", dev->name, |
|
pci_dev->irq); |
|
err = -EIO; |
|
goto fail_irq; |
|
} |
|
} |
|
|
|
pci_set_drvdata(pci_dev, dev); |
|
|
|
/* Init the internal command list */ |
|
for (i = 0; i < SAA_CMD_MAX_MSG_UNITS; i++) { |
|
dev->cmds[i].seqno = i; |
|
dev->cmds[i].inuse = 0; |
|
mutex_init(&dev->cmds[i].lock); |
|
init_waitqueue_head(&dev->cmds[i].wait); |
|
} |
|
|
|
/* We need a deferred interrupt handler for cmd handling */ |
|
INIT_WORK(&dev->workcmd, saa7164_work_cmdhandler); |
|
|
|
/* Only load the firmware if we know the board */ |
|
if (dev->board != SAA7164_BOARD_UNKNOWN) { |
|
|
|
err = saa7164_downloadfirmware(dev); |
|
if (err < 0) { |
|
printk(KERN_ERR |
|
"Failed to boot firmware, no features registered\n"); |
|
goto fail_fw; |
|
} |
|
|
|
saa7164_get_descriptors(dev); |
|
saa7164_dumpregs(dev, 0); |
|
saa7164_getcurrentfirmwareversion(dev); |
|
saa7164_getfirmwarestatus(dev); |
|
err = saa7164_bus_setup(dev); |
|
if (err < 0) |
|
printk(KERN_ERR |
|
"Failed to setup the bus, will continue\n"); |
|
saa7164_bus_dump(dev); |
|
|
|
/* Ping the running firmware via the command bus and get the |
|
* firmware version, this checks the bus is running OK. |
|
*/ |
|
version = 0; |
|
if (saa7164_api_get_fw_version(dev, &version) == SAA_OK) |
|
dprintk(1, "Bus is operating correctly using version %d.%d.%d.%d (0x%x)\n", |
|
(version & 0x0000fc00) >> 10, |
|
(version & 0x000003e0) >> 5, |
|
(version & 0x0000001f), |
|
(version & 0xffff0000) >> 16, |
|
version); |
|
else |
|
printk(KERN_ERR |
|
"Failed to communicate with the firmware\n"); |
|
|
|
/* Bring up the I2C buses */ |
|
saa7164_i2c_register(&dev->i2c_bus[0]); |
|
saa7164_i2c_register(&dev->i2c_bus[1]); |
|
saa7164_i2c_register(&dev->i2c_bus[2]); |
|
saa7164_gpio_setup(dev); |
|
saa7164_card_setup(dev); |
|
|
|
/* Parse the dynamic device configuration, find various |
|
* media endpoints (MPEG, WMV, PS, TS) and cache their |
|
* configuration details into the driver, so we can |
|
* reference them later during simething_register() func, |
|
* interrupt handlers, deferred work handlers etc. |
|
*/ |
|
saa7164_api_enum_subdevs(dev); |
|
|
|
/* Begin to create the video sub-systems and register funcs */ |
|
if (saa7164_boards[dev->board].porta == SAA7164_MPEG_DVB) { |
|
if (saa7164_dvb_register(&dev->ports[SAA7164_PORT_TS1]) < 0) { |
|
printk(KERN_ERR "%s() Failed to register dvb adapters on porta\n", |
|
__func__); |
|
} |
|
} |
|
|
|
if (saa7164_boards[dev->board].portb == SAA7164_MPEG_DVB) { |
|
if (saa7164_dvb_register(&dev->ports[SAA7164_PORT_TS2]) < 0) { |
|
printk(KERN_ERR"%s() Failed to register dvb adapters on portb\n", |
|
__func__); |
|
} |
|
} |
|
|
|
if (saa7164_boards[dev->board].portc == SAA7164_MPEG_ENCODER) { |
|
if (saa7164_encoder_register(&dev->ports[SAA7164_PORT_ENC1]) < 0) { |
|
printk(KERN_ERR"%s() Failed to register mpeg encoder\n", |
|
__func__); |
|
} |
|
} |
|
|
|
if (saa7164_boards[dev->board].portd == SAA7164_MPEG_ENCODER) { |
|
if (saa7164_encoder_register(&dev->ports[SAA7164_PORT_ENC2]) < 0) { |
|
printk(KERN_ERR"%s() Failed to register mpeg encoder\n", |
|
__func__); |
|
} |
|
} |
|
|
|
if (saa7164_boards[dev->board].porte == SAA7164_MPEG_VBI) { |
|
if (saa7164_vbi_register(&dev->ports[SAA7164_PORT_VBI1]) < 0) { |
|
printk(KERN_ERR"%s() Failed to register vbi device\n", |
|
__func__); |
|
} |
|
} |
|
|
|
if (saa7164_boards[dev->board].portf == SAA7164_MPEG_VBI) { |
|
if (saa7164_vbi_register(&dev->ports[SAA7164_PORT_VBI2]) < 0) { |
|
printk(KERN_ERR"%s() Failed to register vbi device\n", |
|
__func__); |
|
} |
|
} |
|
saa7164_api_set_debug(dev, fw_debug); |
|
|
|
if (fw_debug) { |
|
dev->kthread = kthread_run(saa7164_thread_function, dev, |
|
"saa7164 debug"); |
|
if (IS_ERR(dev->kthread)) { |
|
dev->kthread = NULL; |
|
printk(KERN_ERR "%s() Failed to create debug kernel thread\n", |
|
__func__); |
|
} |
|
} |
|
|
|
} /* != BOARD_UNKNOWN */ |
|
else |
|
printk(KERN_ERR "%s() Unsupported board detected, registering without firmware\n", |
|
__func__); |
|
|
|
dprintk(1, "%s() parameter debug = %d\n", __func__, saa_debug); |
|
dprintk(1, "%s() parameter waitsecs = %d\n", __func__, waitsecs); |
|
|
|
fail_fw: |
|
return 0; |
|
|
|
fail_irq: |
|
saa7164_dev_unregister(dev); |
|
fail_free: |
|
v4l2_device_unregister(&dev->v4l2_dev); |
|
kfree(dev); |
|
return err; |
|
} |
|
|
|
static void saa7164_shutdown(struct saa7164_dev *dev) |
|
{ |
|
dprintk(1, "%s()\n", __func__); |
|
} |
|
|
|
static void saa7164_finidev(struct pci_dev *pci_dev) |
|
{ |
|
struct saa7164_dev *dev = pci_get_drvdata(pci_dev); |
|
|
|
if (dev->board != SAA7164_BOARD_UNKNOWN) { |
|
if (fw_debug && dev->kthread) { |
|
kthread_stop(dev->kthread); |
|
dev->kthread = NULL; |
|
} |
|
if (dev->firmwareloaded) |
|
saa7164_api_set_debug(dev, 0x00); |
|
} |
|
|
|
saa7164_histogram_print(&dev->ports[SAA7164_PORT_ENC1], |
|
&dev->ports[SAA7164_PORT_ENC1].irq_interval); |
|
saa7164_histogram_print(&dev->ports[SAA7164_PORT_ENC1], |
|
&dev->ports[SAA7164_PORT_ENC1].svc_interval); |
|
saa7164_histogram_print(&dev->ports[SAA7164_PORT_ENC1], |
|
&dev->ports[SAA7164_PORT_ENC1].irq_svc_interval); |
|
saa7164_histogram_print(&dev->ports[SAA7164_PORT_ENC1], |
|
&dev->ports[SAA7164_PORT_ENC1].read_interval); |
|
saa7164_histogram_print(&dev->ports[SAA7164_PORT_ENC1], |
|
&dev->ports[SAA7164_PORT_ENC1].poll_interval); |
|
saa7164_histogram_print(&dev->ports[SAA7164_PORT_VBI1], |
|
&dev->ports[SAA7164_PORT_VBI1].read_interval); |
|
saa7164_histogram_print(&dev->ports[SAA7164_PORT_VBI2], |
|
&dev->ports[SAA7164_PORT_VBI2].poll_interval); |
|
|
|
saa7164_shutdown(dev); |
|
|
|
if (saa7164_boards[dev->board].porta == SAA7164_MPEG_DVB) |
|
saa7164_dvb_unregister(&dev->ports[SAA7164_PORT_TS1]); |
|
|
|
if (saa7164_boards[dev->board].portb == SAA7164_MPEG_DVB) |
|
saa7164_dvb_unregister(&dev->ports[SAA7164_PORT_TS2]); |
|
|
|
if (saa7164_boards[dev->board].portc == SAA7164_MPEG_ENCODER) |
|
saa7164_encoder_unregister(&dev->ports[SAA7164_PORT_ENC1]); |
|
|
|
if (saa7164_boards[dev->board].portd == SAA7164_MPEG_ENCODER) |
|
saa7164_encoder_unregister(&dev->ports[SAA7164_PORT_ENC2]); |
|
|
|
if (saa7164_boards[dev->board].porte == SAA7164_MPEG_VBI) |
|
saa7164_vbi_unregister(&dev->ports[SAA7164_PORT_VBI1]); |
|
|
|
if (saa7164_boards[dev->board].portf == SAA7164_MPEG_VBI) |
|
saa7164_vbi_unregister(&dev->ports[SAA7164_PORT_VBI2]); |
|
|
|
saa7164_i2c_unregister(&dev->i2c_bus[0]); |
|
saa7164_i2c_unregister(&dev->i2c_bus[1]); |
|
saa7164_i2c_unregister(&dev->i2c_bus[2]); |
|
|
|
/* unregister stuff */ |
|
free_irq(pci_dev->irq, dev); |
|
|
|
if (dev->msi) { |
|
pci_disable_msi(pci_dev); |
|
dev->msi = false; |
|
} |
|
|
|
pci_disable_device(pci_dev); |
|
|
|
mutex_lock(&devlist); |
|
list_del(&dev->devlist); |
|
mutex_unlock(&devlist); |
|
|
|
saa7164_dev_unregister(dev); |
|
v4l2_device_unregister(&dev->v4l2_dev); |
|
kfree(dev); |
|
} |
|
|
|
static const struct pci_device_id saa7164_pci_tbl[] = { |
|
{ |
|
/* SAA7164 */ |
|
.vendor = 0x1131, |
|
.device = 0x7164, |
|
.subvendor = PCI_ANY_ID, |
|
.subdevice = PCI_ANY_ID, |
|
}, { |
|
/* --- end of list --- */ |
|
} |
|
}; |
|
MODULE_DEVICE_TABLE(pci, saa7164_pci_tbl); |
|
|
|
static struct pci_driver saa7164_pci_driver = { |
|
.name = "saa7164", |
|
.id_table = saa7164_pci_tbl, |
|
.probe = saa7164_initdev, |
|
.remove = saa7164_finidev, |
|
}; |
|
|
|
static int __init saa7164_init(void) |
|
{ |
|
int ret = pci_register_driver(&saa7164_pci_driver); |
|
|
|
if (ret) |
|
return ret; |
|
|
|
saa7164_debugfs_create(); |
|
|
|
pr_info("saa7164 driver loaded\n"); |
|
|
|
return 0; |
|
} |
|
|
|
static void __exit saa7164_fini(void) |
|
{ |
|
saa7164_debugfs_remove(); |
|
pci_unregister_driver(&saa7164_pci_driver); |
|
} |
|
|
|
module_init(saa7164_init); |
|
module_exit(saa7164_fini);
|
|
|