2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Zoran zr36057/zr36067 PCI controller driver, for the
|
|
|
|
* Pinnacle/Miro DC10/DC10+/DC30/DC30+, Iomega Buz, Linux
|
|
|
|
* Media Labs LML33/LML33R10.
|
|
|
|
*
|
|
|
|
* This part handles device access (PCI/I2C/codec/...)
|
2006-03-25 12:19:53 +00:00
|
|
|
*
|
2005-04-16 22:20:36 +00:00
|
|
|
* Copyright (C) 2000 Serguei Miridonov <mirsev@cicese.mx>
|
|
|
|
*
|
|
|
|
* Currently maintained by:
|
|
|
|
* Ronald Bultje <rbultje@ronald.bitfreak.net>
|
|
|
|
* Laurent Pinchart <laurent.pinchart@skynet.be>
|
|
|
|
* Mailinglist <mjpeg-users@lists.sf.net>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/vmalloc.h>
|
2015-08-11 15:09:49 +00:00
|
|
|
#include <linux/ktime.h>
|
2017-02-02 18:15:33 +00:00
|
|
|
#include <linux/sched/signal.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/proc_fs.h>
|
|
|
|
#include <linux/i2c.h>
|
|
|
|
#include <linux/i2c-algo-bit.h>
|
2009-02-18 20:26:06 +00:00
|
|
|
#include <linux/videodev2.h>
|
|
|
|
#include <media/v4l2-common.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/sem.h>
|
|
|
|
|
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/wait.h>
|
|
|
|
|
2008-05-16 18:20:25 +00:00
|
|
|
#include <asm/byteorder.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <asm/io.h>
|
|
|
|
|
|
|
|
#include "videocodec.h"
|
|
|
|
#include "zoran.h"
|
|
|
|
#include "zoran_device.h"
|
2007-07-17 21:29:41 +00:00
|
|
|
#include "zoran_card.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#define IRQ_MASK ( ZR36057_ISR_GIRQ0 | \
|
|
|
|
ZR36057_ISR_GIRQ1 | \
|
|
|
|
ZR36057_ISR_JPEGRepIRQ )
|
|
|
|
|
2012-01-12 23:02:20 +00:00
|
|
|
static bool lml33dpath; /* default = 0
|
2008-04-22 17:41:48 +00:00
|
|
|
* 1 will use digital path in capture
|
2005-04-16 22:20:36 +00:00
|
|
|
* mode instead of analog. It can be
|
|
|
|
* used for picture adjustments using
|
|
|
|
* tool like xawtv while watching image
|
|
|
|
* on TV monitor connected to the output.
|
|
|
|
* However, due to absence of 75 Ohm
|
|
|
|
* load on Bt819 input, there will be
|
|
|
|
* some image imperfections */
|
|
|
|
|
2007-07-17 21:29:42 +00:00
|
|
|
module_param(lml33dpath, bool, 0644);
|
2005-04-16 22:20:36 +00:00
|
|
|
MODULE_PARM_DESC(lml33dpath,
|
|
|
|
"Use digital path capture mode (on LML33 cards)");
|
|
|
|
|
|
|
|
static void
|
|
|
|
zr36057_init_vfe (struct zoran *zr);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* General Purpose I/O and Guest bus access
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is a bit tricky. When a board lacks a GPIO function, the corresponding
|
|
|
|
* GPIO bit number in the card_info structure is set to 0.
|
|
|
|
*/
|
|
|
|
|
|
|
|
void
|
|
|
|
GPIO (struct zoran *zr,
|
|
|
|
int bit,
|
|
|
|
unsigned int value)
|
|
|
|
{
|
|
|
|
u32 reg;
|
|
|
|
u32 mask;
|
|
|
|
|
|
|
|
/* Make sure the bit number is legal
|
|
|
|
* A bit number of -1 (lacking) gives a mask of 0,
|
|
|
|
* making it harmless */
|
|
|
|
mask = (1 << (24 + bit)) & 0xff000000;
|
|
|
|
reg = btread(ZR36057_GPPGCR1) & ~mask;
|
|
|
|
if (value) {
|
|
|
|
reg |= mask;
|
|
|
|
}
|
|
|
|
btwrite(reg, ZR36057_GPPGCR1);
|
|
|
|
udelay(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wait til post office is no longer busy
|
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
|
|
|
post_office_wait (struct zoran *zr)
|
|
|
|
{
|
|
|
|
u32 por;
|
|
|
|
|
|
|
|
// while (((por = btread(ZR36057_POR)) & (ZR36057_POR_POPen | ZR36057_POR_POTime)) == ZR36057_POR_POPen) {
|
|
|
|
while ((por = btread(ZR36057_POR)) & ZR36057_POR_POPen) {
|
|
|
|
/* wait for something to happen */
|
|
|
|
}
|
|
|
|
if ((por & ZR36057_POR_POTime) && !zr->card.gws_not_connected) {
|
|
|
|
/* In LML33/BUZ \GWS line is not connected, so it has always timeout set */
|
|
|
|
dprintk(1, KERN_INFO "%s: pop timeout %08x\n", ZR_DEVNAME(zr),
|
|
|
|
por);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
post_office_write (struct zoran *zr,
|
|
|
|
unsigned int guest,
|
|
|
|
unsigned int reg,
|
|
|
|
unsigned int value)
|
|
|
|
{
|
|
|
|
u32 por;
|
|
|
|
|
|
|
|
por =
|
|
|
|
ZR36057_POR_PODir | ZR36057_POR_POTime | ((guest & 7) << 20) |
|
|
|
|
((reg & 7) << 16) | (value & 0xFF);
|
|
|
|
btwrite(por, ZR36057_POR);
|
|
|
|
|
|
|
|
return post_office_wait(zr);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
post_office_read (struct zoran *zr,
|
|
|
|
unsigned int guest,
|
|
|
|
unsigned int reg)
|
|
|
|
{
|
|
|
|
u32 por;
|
|
|
|
|
|
|
|
por = ZR36057_POR_POTime | ((guest & 7) << 20) | ((reg & 7) << 16);
|
|
|
|
btwrite(por, ZR36057_POR);
|
|
|
|
if (post_office_wait(zr) < 0) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return btread(ZR36057_POR) & 0xFF;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* detect guests
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
dump_guests (struct zoran *zr)
|
|
|
|
{
|
2007-07-17 21:29:41 +00:00
|
|
|
if (zr36067_debug > 2) {
|
2005-04-16 22:20:36 +00:00
|
|
|
int i, guest[8];
|
|
|
|
|
|
|
|
for (i = 1; i < 8; i++) { // Don't read jpeg codec here
|
|
|
|
guest[i] = post_office_read(zr, i, 0);
|
|
|
|
}
|
|
|
|
|
2016-10-14 10:27:36 +00:00
|
|
|
printk(KERN_INFO "%s: Guests: %*ph\n",
|
|
|
|
ZR_DEVNAME(zr), 8, guest);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
detect_guest_activity (struct zoran *zr)
|
|
|
|
{
|
|
|
|
int timeout, i, j, res, guest[8], guest0[8], change[8][3];
|
2015-08-11 15:09:49 +00:00
|
|
|
ktime_t t0, t1;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
dump_guests(zr);
|
|
|
|
printk(KERN_INFO "%s: Detecting guests activity, please wait...\n",
|
|
|
|
ZR_DEVNAME(zr));
|
|
|
|
for (i = 1; i < 8; i++) { // Don't read jpeg codec here
|
|
|
|
guest0[i] = guest[i] = post_office_read(zr, i, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
timeout = 0;
|
|
|
|
j = 0;
|
2015-08-11 15:09:49 +00:00
|
|
|
t0 = ktime_get();
|
2005-04-16 22:20:36 +00:00
|
|
|
while (timeout < 10000) {
|
|
|
|
udelay(10);
|
|
|
|
timeout++;
|
|
|
|
for (i = 1; (i < 8) && (j < 8); i++) {
|
|
|
|
res = post_office_read(zr, i, 0);
|
|
|
|
if (res != guest[i]) {
|
2015-08-11 15:09:49 +00:00
|
|
|
t1 = ktime_get();
|
|
|
|
change[j][0] = ktime_to_us(ktime_sub(t1, t0));
|
2005-04-16 22:20:36 +00:00
|
|
|
t0 = t1;
|
|
|
|
change[j][1] = i;
|
|
|
|
change[j][2] = res;
|
|
|
|
j++;
|
|
|
|
guest[i] = res;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (j >= 8)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2016-10-14 10:27:36 +00:00
|
|
|
printk(KERN_INFO "%s: Guests: %*ph\n", ZR_DEVNAME(zr), 8, guest0);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (j == 0) {
|
|
|
|
printk(KERN_INFO "%s: No activity detected.\n", ZR_DEVNAME(zr));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
for (i = 0; i < j; i++) {
|
|
|
|
printk(KERN_INFO "%s: %6d: %d => 0x%02x\n", ZR_DEVNAME(zr),
|
|
|
|
change[i][0], change[i][1], change[i][2]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* JPEG Codec access
|
|
|
|
*/
|
|
|
|
|
|
|
|
void
|
|
|
|
jpeg_codec_sleep (struct zoran *zr,
|
|
|
|
int sleep)
|
|
|
|
{
|
2008-02-15 21:41:06 +00:00
|
|
|
GPIO(zr, zr->card.gpio[ZR_GPIO_JPEG_SLEEP], !sleep);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!sleep) {
|
|
|
|
dprintk(3,
|
|
|
|
KERN_DEBUG
|
|
|
|
"%s: jpeg_codec_sleep() - wake GPIO=0x%08x\n",
|
|
|
|
ZR_DEVNAME(zr), btread(ZR36057_GPPGCR1));
|
|
|
|
udelay(500);
|
|
|
|
} else {
|
|
|
|
dprintk(3,
|
|
|
|
KERN_DEBUG
|
|
|
|
"%s: jpeg_codec_sleep() - sleep GPIO=0x%08x\n",
|
|
|
|
ZR_DEVNAME(zr), btread(ZR36057_GPPGCR1));
|
|
|
|
udelay(2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
jpeg_codec_reset (struct zoran *zr)
|
|
|
|
{
|
|
|
|
/* Take the codec out of sleep */
|
|
|
|
jpeg_codec_sleep(zr, 0);
|
|
|
|
|
|
|
|
if (zr->card.gpcs[GPCS_JPEG_RESET] != 0xff) {
|
|
|
|
post_office_write(zr, zr->card.gpcs[GPCS_JPEG_RESET], 0,
|
|
|
|
0);
|
|
|
|
udelay(2);
|
|
|
|
} else {
|
2008-02-15 21:41:06 +00:00
|
|
|
GPIO(zr, zr->card.gpio[ZR_GPIO_JPEG_RESET], 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
udelay(2);
|
2008-02-15 21:41:06 +00:00
|
|
|
GPIO(zr, zr->card.gpio[ZR_GPIO_JPEG_RESET], 1);
|
2005-04-16 22:20:36 +00:00
|
|
|
udelay(2);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set the registers for the size we have specified. Don't bother
|
|
|
|
* trying to understand this without the ZR36057 manual in front of
|
|
|
|
* you [AC].
|
|
|
|
*
|
|
|
|
* PS: The manual is free for download in .pdf format from
|
|
|
|
* www.zoran.com - nicely done those folks.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
zr36057_adjust_vfe (struct zoran *zr,
|
|
|
|
enum zoran_codec_mode mode)
|
|
|
|
{
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
switch (mode) {
|
|
|
|
case BUZ_MODE_MOTION_DECOMPRESS:
|
|
|
|
btand(~ZR36057_VFESPFR_ExtFl, ZR36057_VFESPFR);
|
|
|
|
reg = btread(ZR36057_VFEHCR);
|
|
|
|
if ((reg & (1 << 10)) && zr->card.type != LML33R10) {
|
|
|
|
reg += ((1 << 10) | 1);
|
|
|
|
}
|
|
|
|
btwrite(reg, ZR36057_VFEHCR);
|
|
|
|
break;
|
|
|
|
case BUZ_MODE_MOTION_COMPRESS:
|
|
|
|
case BUZ_MODE_IDLE:
|
|
|
|
default:
|
2009-02-18 20:26:06 +00:00
|
|
|
if ((zr->norm & V4L2_STD_NTSC) ||
|
2005-04-16 22:20:36 +00:00
|
|
|
(zr->card.type == LML33R10 &&
|
2009-02-18 20:26:06 +00:00
|
|
|
(zr->norm & V4L2_STD_PAL)))
|
2005-04-16 22:20:36 +00:00
|
|
|
btand(~ZR36057_VFESPFR_ExtFl, ZR36057_VFESPFR);
|
|
|
|
else
|
|
|
|
btor(ZR36057_VFESPFR_ExtFl, ZR36057_VFESPFR);
|
|
|
|
reg = btread(ZR36057_VFEHCR);
|
|
|
|
if (!(reg & (1 << 10)) && zr->card.type != LML33R10) {
|
|
|
|
reg -= ((1 << 10) | 1);
|
|
|
|
}
|
|
|
|
btwrite(reg, ZR36057_VFEHCR);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* set geometry
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
zr36057_set_vfe (struct zoran *zr,
|
|
|
|
int video_width,
|
|
|
|
int video_height,
|
|
|
|
const struct zoran_format *format)
|
|
|
|
{
|
|
|
|
struct tvnorm *tvn;
|
|
|
|
unsigned HStart, HEnd, VStart, VEnd;
|
|
|
|
unsigned DispMode;
|
|
|
|
unsigned VidWinWid, VidWinHt;
|
|
|
|
unsigned hcrop1, hcrop2, vcrop1, vcrop2;
|
|
|
|
unsigned Wa, We, Ha, He;
|
|
|
|
unsigned X, Y, HorDcm, VerDcm;
|
|
|
|
u32 reg;
|
|
|
|
unsigned mask_line_size;
|
|
|
|
|
|
|
|
tvn = zr->timing;
|
|
|
|
|
|
|
|
Wa = tvn->Wa;
|
|
|
|
Ha = tvn->Ha;
|
|
|
|
|
|
|
|
dprintk(2, KERN_INFO "%s: set_vfe() - width = %d, height = %d\n",
|
|
|
|
ZR_DEVNAME(zr), video_width, video_height);
|
|
|
|
|
|
|
|
if (video_width < BUZ_MIN_WIDTH ||
|
|
|
|
video_height < BUZ_MIN_HEIGHT ||
|
|
|
|
video_width > Wa || video_height > Ha) {
|
|
|
|
dprintk(1, KERN_ERR "%s: set_vfe: w=%d h=%d not valid\n",
|
|
|
|
ZR_DEVNAME(zr), video_width, video_height);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** zr36057 ****/
|
|
|
|
|
|
|
|
/* horizontal */
|
|
|
|
VidWinWid = video_width;
|
2008-08-20 23:44:53 +00:00
|
|
|
X = DIV_ROUND_UP(VidWinWid * 64, tvn->Wa);
|
2005-04-16 22:20:36 +00:00
|
|
|
We = (VidWinWid * 64) / X;
|
|
|
|
HorDcm = 64 - X;
|
|
|
|
hcrop1 = 2 * ((tvn->Wa - We) / 4);
|
|
|
|
hcrop2 = tvn->Wa - We - hcrop1;
|
|
|
|
HStart = tvn->HStart ? tvn->HStart : 1;
|
|
|
|
/* (Ronald) Original comment:
|
|
|
|
* "| 1 Doesn't have any effect, tested on both a DC10 and a DC10+"
|
|
|
|
* this is false. It inverses chroma values on the LML33R10 (so Cr
|
|
|
|
* suddenly is shown as Cb and reverse, really cool effect if you
|
|
|
|
* want to see blue faces, not useful otherwise). So don't use |1.
|
|
|
|
* However, the DC10 has '0' as HStart, but does need |1, so we
|
|
|
|
* use a dirty check...
|
|
|
|
*/
|
|
|
|
HEnd = HStart + tvn->Wa - 1;
|
|
|
|
HStart += hcrop1;
|
|
|
|
HEnd -= hcrop2;
|
|
|
|
reg = ((HStart & ZR36057_VFEHCR_Hmask) << ZR36057_VFEHCR_HStart)
|
|
|
|
| ((HEnd & ZR36057_VFEHCR_Hmask) << ZR36057_VFEHCR_HEnd);
|
|
|
|
if (zr->card.vfe_pol.hsync_pol)
|
|
|
|
reg |= ZR36057_VFEHCR_HSPol;
|
|
|
|
btwrite(reg, ZR36057_VFEHCR);
|
|
|
|
|
|
|
|
/* Vertical */
|
|
|
|
DispMode = !(video_height > BUZ_MAX_HEIGHT / 2);
|
|
|
|
VidWinHt = DispMode ? video_height : video_height / 2;
|
2008-08-20 23:44:53 +00:00
|
|
|
Y = DIV_ROUND_UP(VidWinHt * 64 * 2, tvn->Ha);
|
2005-04-16 22:20:36 +00:00
|
|
|
He = (VidWinHt * 64) / Y;
|
|
|
|
VerDcm = 64 - Y;
|
|
|
|
vcrop1 = (tvn->Ha / 2 - He) / 2;
|
|
|
|
vcrop2 = tvn->Ha / 2 - He - vcrop1;
|
|
|
|
VStart = tvn->VStart;
|
|
|
|
VEnd = VStart + tvn->Ha / 2; // - 1; FIXME SnapShot times out with -1 in 768*576 on the DC10 - LP
|
|
|
|
VStart += vcrop1;
|
|
|
|
VEnd -= vcrop2;
|
|
|
|
reg = ((VStart & ZR36057_VFEVCR_Vmask) << ZR36057_VFEVCR_VStart)
|
|
|
|
| ((VEnd & ZR36057_VFEVCR_Vmask) << ZR36057_VFEVCR_VEnd);
|
|
|
|
if (zr->card.vfe_pol.vsync_pol)
|
|
|
|
reg |= ZR36057_VFEVCR_VSPol;
|
|
|
|
btwrite(reg, ZR36057_VFEVCR);
|
|
|
|
|
|
|
|
/* scaler and pixel format */
|
|
|
|
reg = 0;
|
|
|
|
reg |= (HorDcm << ZR36057_VFESPFR_HorDcm);
|
|
|
|
reg |= (VerDcm << ZR36057_VFESPFR_VerDcm);
|
|
|
|
reg |= (DispMode << ZR36057_VFESPFR_DispMode);
|
|
|
|
/* RJ: I don't know, why the following has to be the opposite
|
|
|
|
* of the corresponding ZR36060 setting, but only this way
|
|
|
|
* we get the correct colors when uncompressing to the screen */
|
|
|
|
//reg |= ZR36057_VFESPFR_VCLKPol; /**/
|
|
|
|
/* RJ: Don't know if that is needed for NTSC also */
|
2009-02-18 20:26:06 +00:00
|
|
|
if (!(zr->norm & V4L2_STD_NTSC))
|
2005-04-16 22:20:36 +00:00
|
|
|
reg |= ZR36057_VFESPFR_ExtFl; // NEEDED!!!!!!! Wolfgang
|
|
|
|
reg |= ZR36057_VFESPFR_TopField;
|
|
|
|
if (HorDcm >= 48) {
|
|
|
|
reg |= 3 << ZR36057_VFESPFR_HFilter; /* 5 tap filter */
|
|
|
|
} else if (HorDcm >= 32) {
|
|
|
|
reg |= 2 << ZR36057_VFESPFR_HFilter; /* 4 tap filter */
|
|
|
|
} else if (HorDcm >= 16) {
|
|
|
|
reg |= 1 << ZR36057_VFESPFR_HFilter; /* 3 tap filter */
|
|
|
|
}
|
2007-07-17 21:29:44 +00:00
|
|
|
reg |= format->vfespfr;
|
2005-04-16 22:20:36 +00:00
|
|
|
btwrite(reg, ZR36057_VFESPFR);
|
|
|
|
|
|
|
|
/* display configuration */
|
|
|
|
reg = (16 << ZR36057_VDCR_MinPix)
|
|
|
|
| (VidWinHt << ZR36057_VDCR_VidWinHt)
|
|
|
|
| (VidWinWid << ZR36057_VDCR_VidWinWid);
|
|
|
|
if (pci_pci_problems & PCIPCI_TRITON)
|
|
|
|
// || zr->revision < 1) // Revision 1 has also Triton support
|
|
|
|
reg &= ~ZR36057_VDCR_Triton;
|
|
|
|
else
|
|
|
|
reg |= ZR36057_VDCR_Triton;
|
|
|
|
btwrite(reg, ZR36057_VDCR);
|
|
|
|
|
|
|
|
/* (Ronald) don't write this if overlay_mask = NULL */
|
|
|
|
if (zr->overlay_mask) {
|
|
|
|
/* Write overlay clipping mask data, but don't enable overlay clipping */
|
2006-03-25 12:19:53 +00:00
|
|
|
/* RJ: since this makes only sense on the screen, we use
|
2005-04-16 22:20:36 +00:00
|
|
|
* zr->overlay_settings.width instead of video_width */
|
|
|
|
|
|
|
|
mask_line_size = (BUZ_MAX_WIDTH + 31) / 32;
|
|
|
|
reg = virt_to_bus(zr->overlay_mask);
|
|
|
|
btwrite(reg, ZR36057_MMTR);
|
|
|
|
reg = virt_to_bus(zr->overlay_mask + mask_line_size);
|
|
|
|
btwrite(reg, ZR36057_MMBR);
|
|
|
|
reg =
|
|
|
|
mask_line_size - (zr->overlay_settings.width +
|
|
|
|
31) / 32;
|
|
|
|
if (DispMode == 0)
|
|
|
|
reg += mask_line_size;
|
|
|
|
reg <<= ZR36057_OCR_MaskStride;
|
|
|
|
btwrite(reg, ZR36057_OCR);
|
|
|
|
}
|
|
|
|
|
|
|
|
zr36057_adjust_vfe(zr, zr->codec_mode);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Switch overlay on or off
|
|
|
|
*/
|
|
|
|
|
|
|
|
void
|
|
|
|
zr36057_overlay (struct zoran *zr,
|
|
|
|
int on)
|
|
|
|
{
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
if (on) {
|
|
|
|
/* do the necessary settings ... */
|
|
|
|
btand(~ZR36057_VDCR_VidEn, ZR36057_VDCR); /* switch it off first */
|
|
|
|
|
|
|
|
zr36057_set_vfe(zr,
|
|
|
|
zr->overlay_settings.width,
|
|
|
|
zr->overlay_settings.height,
|
|
|
|
zr->overlay_settings.format);
|
|
|
|
|
|
|
|
/* Start and length of each line MUST be 4-byte aligned.
|
2010-07-02 18:41:51 +00:00
|
|
|
* This should be already checked before the call to this routine.
|
2005-04-16 22:20:36 +00:00
|
|
|
* All error messages are internal driver checking only! */
|
|
|
|
|
|
|
|
/* video display top and bottom registers */
|
2009-02-19 20:31:17 +00:00
|
|
|
reg = (long) zr->vbuf_base +
|
2005-04-16 22:20:36 +00:00
|
|
|
zr->overlay_settings.x *
|
|
|
|
((zr->overlay_settings.format->depth + 7) / 8) +
|
|
|
|
zr->overlay_settings.y *
|
2009-02-19 20:31:17 +00:00
|
|
|
zr->vbuf_bytesperline;
|
2005-04-16 22:20:36 +00:00
|
|
|
btwrite(reg, ZR36057_VDTR);
|
|
|
|
if (reg & 3)
|
|
|
|
dprintk(1,
|
|
|
|
KERN_ERR
|
|
|
|
"%s: zr36057_overlay() - video_address not aligned\n",
|
|
|
|
ZR_DEVNAME(zr));
|
|
|
|
if (zr->overlay_settings.height > BUZ_MAX_HEIGHT / 2)
|
2009-02-19 20:31:17 +00:00
|
|
|
reg += zr->vbuf_bytesperline;
|
2005-04-16 22:20:36 +00:00
|
|
|
btwrite(reg, ZR36057_VDBR);
|
|
|
|
|
|
|
|
/* video stride, status, and frame grab register */
|
2009-02-19 20:31:17 +00:00
|
|
|
reg = zr->vbuf_bytesperline -
|
2005-04-16 22:20:36 +00:00
|
|
|
zr->overlay_settings.width *
|
|
|
|
((zr->overlay_settings.format->depth + 7) / 8);
|
|
|
|
if (zr->overlay_settings.height > BUZ_MAX_HEIGHT / 2)
|
2009-02-19 20:31:17 +00:00
|
|
|
reg += zr->vbuf_bytesperline;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (reg & 3)
|
|
|
|
dprintk(1,
|
|
|
|
KERN_ERR
|
|
|
|
"%s: zr36057_overlay() - video_stride not aligned\n",
|
|
|
|
ZR_DEVNAME(zr));
|
|
|
|
reg = (reg << ZR36057_VSSFGR_DispStride);
|
|
|
|
reg |= ZR36057_VSSFGR_VidOvf; /* clear overflow status */
|
|
|
|
btwrite(reg, ZR36057_VSSFGR);
|
|
|
|
|
|
|
|
/* Set overlay clipping */
|
|
|
|
if (zr->overlay_settings.clipcount > 0)
|
|
|
|
btor(ZR36057_OCR_OvlEnable, ZR36057_OCR);
|
|
|
|
|
|
|
|
/* ... and switch it on */
|
|
|
|
btor(ZR36057_VDCR_VidEn, ZR36057_VDCR);
|
|
|
|
} else {
|
|
|
|
/* Switch it off */
|
|
|
|
btand(~ZR36057_VDCR_VidEn, ZR36057_VDCR);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The overlay mask has one bit for each pixel on a scan line,
|
|
|
|
* and the maximum window size is BUZ_MAX_WIDTH * BUZ_MAX_HEIGHT pixels.
|
|
|
|
*/
|
|
|
|
|
2009-03-11 02:28:31 +00:00
|
|
|
void write_overlay_mask(struct zoran_fh *fh, struct v4l2_clip *vp, int count)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct zoran *zr = fh->zr;
|
|
|
|
unsigned mask_line_size = (BUZ_MAX_WIDTH + 31) / 32;
|
|
|
|
u32 *mask;
|
|
|
|
int x, y, width, height;
|
|
|
|
unsigned i, j, k;
|
|
|
|
|
|
|
|
/* fill mask with one bits */
|
|
|
|
memset(fh->overlay_mask, ~0, mask_line_size * 4 * BUZ_MAX_HEIGHT);
|
|
|
|
|
|
|
|
for (i = 0; i < count; ++i) {
|
|
|
|
/* pick up local copy of clip */
|
2009-02-19 20:31:17 +00:00
|
|
|
x = vp[i].c.left;
|
|
|
|
y = vp[i].c.top;
|
|
|
|
width = vp[i].c.width;
|
|
|
|
height = vp[i].c.height;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* trim clips that extend beyond the window */
|
|
|
|
if (x < 0) {
|
|
|
|
width += x;
|
|
|
|
x = 0;
|
|
|
|
}
|
|
|
|
if (y < 0) {
|
|
|
|
height += y;
|
|
|
|
y = 0;
|
|
|
|
}
|
|
|
|
if (x + width > fh->overlay_settings.width) {
|
|
|
|
width = fh->overlay_settings.width - x;
|
|
|
|
}
|
|
|
|
if (y + height > fh->overlay_settings.height) {
|
|
|
|
height = fh->overlay_settings.height - y;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ignore degenerate clips */
|
|
|
|
if (height <= 0) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (width <= 0) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* apply clip for each scan line */
|
|
|
|
for (j = 0; j < height; ++j) {
|
|
|
|
/* reset bit for each pixel */
|
|
|
|
/* this can be optimized later if need be */
|
|
|
|
mask = fh->overlay_mask + (y + j) * mask_line_size;
|
|
|
|
for (k = 0; k < width; ++k) {
|
|
|
|
mask[(x + k) / 32] &=
|
|
|
|
~((u32) 1 << (x + k) % 32);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Enable/Disable uncompressed memory grabbing of the 36057 */
|
|
|
|
|
|
|
|
void
|
|
|
|
zr36057_set_memgrab (struct zoran *zr,
|
|
|
|
int mode)
|
|
|
|
{
|
|
|
|
if (mode) {
|
2007-07-17 21:29:45 +00:00
|
|
|
/* We only check SnapShot and not FrameGrab here. SnapShot==1
|
|
|
|
* means a capture is already in progress, but FrameGrab==1
|
|
|
|
* doesn't necessary mean that. It's more correct to say a 1
|
|
|
|
* to 0 transition indicates a capture completed. If a
|
|
|
|
* capture is pending when capturing is tuned off, FrameGrab
|
|
|
|
* will be stuck at 1 until capturing is turned back on.
|
|
|
|
*/
|
|
|
|
if (btread(ZR36057_VSSFGR) & ZR36057_VSSFGR_SnapShot)
|
2005-04-16 22:20:36 +00:00
|
|
|
dprintk(1,
|
|
|
|
KERN_WARNING
|
2007-07-17 21:29:45 +00:00
|
|
|
"%s: zr36057_set_memgrab(1) with SnapShot on!?\n",
|
2005-04-16 22:20:36 +00:00
|
|
|
ZR_DEVNAME(zr));
|
|
|
|
|
|
|
|
/* switch on VSync interrupts */
|
|
|
|
btwrite(IRQ_MASK, ZR36057_ISR); // Clear Interrupts
|
|
|
|
btor(zr->card.vsync_int, ZR36057_ICR); // SW
|
|
|
|
|
|
|
|
/* enable SnapShot */
|
|
|
|
btor(ZR36057_VSSFGR_SnapShot, ZR36057_VSSFGR);
|
|
|
|
|
|
|
|
/* Set zr36057 video front end and enable video */
|
|
|
|
zr36057_set_vfe(zr, zr->v4l_settings.width,
|
|
|
|
zr->v4l_settings.height,
|
|
|
|
zr->v4l_settings.format);
|
|
|
|
|
|
|
|
zr->v4l_memgrab_active = 1;
|
|
|
|
} else {
|
|
|
|
/* switch off VSync interrupts */
|
|
|
|
btand(~zr->card.vsync_int, ZR36057_ICR); // SW
|
|
|
|
|
2007-07-17 21:29:45 +00:00
|
|
|
zr->v4l_memgrab_active = 0;
|
|
|
|
zr->v4l_grab_frame = NO_GRAB_ACTIVE;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* reenable grabbing to screen if it was running */
|
|
|
|
if (zr->v4l_overlay_active) {
|
|
|
|
zr36057_overlay(zr, 1);
|
|
|
|
} else {
|
|
|
|
btand(~ZR36057_VDCR_VidEn, ZR36057_VDCR);
|
|
|
|
btand(~ZR36057_VSSFGR_SnapShot, ZR36057_VSSFGR);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
wait_grab_pending (struct zoran *zr)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
/* wait until all pending grabs are finished */
|
|
|
|
|
|
|
|
if (!zr->v4l_memgrab_active)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
wait_event_interruptible(zr->v4l_capq,
|
|
|
|
(zr->v4l_pend_tail == zr->v4l_pend_head));
|
|
|
|
if (signal_pending(current))
|
|
|
|
return -ERESTARTSYS;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&zr->spinlock, flags);
|
|
|
|
zr36057_set_memgrab(zr, 0);
|
|
|
|
spin_unlock_irqrestore(&zr->spinlock, flags);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
* *
|
|
|
|
* Set up the Buz-specific MJPEG part *
|
|
|
|
* *
|
|
|
|
*****************************************************************************/
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
set_frame (struct zoran *zr,
|
|
|
|
int val)
|
|
|
|
{
|
2008-02-15 21:41:06 +00:00
|
|
|
GPIO(zr, zr->card.gpio[ZR_GPIO_JPEG_FRAME], val);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
set_videobus_dir (struct zoran *zr,
|
|
|
|
int val)
|
|
|
|
{
|
|
|
|
switch (zr->card.type) {
|
|
|
|
case LML33:
|
|
|
|
case LML33R10:
|
2014-09-03 18:39:01 +00:00
|
|
|
if (!lml33dpath)
|
2005-04-16 22:20:36 +00:00
|
|
|
GPIO(zr, 5, val);
|
|
|
|
else
|
|
|
|
GPIO(zr, 5, 1);
|
|
|
|
break;
|
|
|
|
default:
|
2008-02-15 21:41:06 +00:00
|
|
|
GPIO(zr, zr->card.gpio[ZR_GPIO_VID_DIR],
|
|
|
|
zr->card.gpio_pol[ZR_GPIO_VID_DIR] ? !val : val);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
init_jpeg_queue (struct zoran *zr)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* re-initialize DMA ring stuff */
|
|
|
|
zr->jpg_que_head = 0;
|
|
|
|
zr->jpg_dma_head = 0;
|
|
|
|
zr->jpg_dma_tail = 0;
|
|
|
|
zr->jpg_que_tail = 0;
|
|
|
|
zr->jpg_seq_num = 0;
|
|
|
|
zr->JPEG_error = 0;
|
|
|
|
zr->num_errors = 0;
|
|
|
|
zr->jpg_err_seq = 0;
|
|
|
|
zr->jpg_err_shift = 0;
|
|
|
|
zr->jpg_queued_num = 0;
|
|
|
|
for (i = 0; i < zr->jpg_buffers.num_buffers; i++) {
|
|
|
|
zr->jpg_buffers.buffer[i].state = BUZ_STATE_USER; /* nothing going on */
|
|
|
|
}
|
|
|
|
for (i = 0; i < BUZ_NUM_STAT_COM; i++) {
|
|
|
|
zr->stat_com[i] = cpu_to_le32(1); /* mark as unavailable to zr36057 */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
zr36057_set_jpg (struct zoran *zr,
|
|
|
|
enum zoran_codec_mode mode)
|
|
|
|
{
|
|
|
|
struct tvnorm *tvn;
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
tvn = zr->timing;
|
|
|
|
|
|
|
|
/* assert P_Reset, disable code transfer, deassert Active */
|
|
|
|
btwrite(0, ZR36057_JPC);
|
|
|
|
|
|
|
|
/* MJPEG compression mode */
|
|
|
|
switch (mode) {
|
|
|
|
|
|
|
|
case BUZ_MODE_MOTION_COMPRESS:
|
|
|
|
default:
|
|
|
|
reg = ZR36057_JMC_MJPGCmpMode;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case BUZ_MODE_MOTION_DECOMPRESS:
|
|
|
|
reg = ZR36057_JMC_MJPGExpMode;
|
|
|
|
reg |= ZR36057_JMC_SyncMstr;
|
|
|
|
/* RJ: The following is experimental - improves the output to screen */
|
|
|
|
//if(zr->jpg_settings.VFIFO_FB) reg |= ZR36057_JMC_VFIFO_FB; // No, it doesn't. SM
|
|
|
|
break;
|
|
|
|
|
|
|
|
case BUZ_MODE_STILL_COMPRESS:
|
|
|
|
reg = ZR36057_JMC_JPGCmpMode;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case BUZ_MODE_STILL_DECOMPRESS:
|
|
|
|
reg = ZR36057_JMC_JPGExpMode;
|
|
|
|
break;
|
|
|
|
|
|
|
|
}
|
|
|
|
reg |= ZR36057_JMC_JPG;
|
|
|
|
if (zr->jpg_settings.field_per_buff == 1)
|
|
|
|
reg |= ZR36057_JMC_Fld_per_buff;
|
|
|
|
btwrite(reg, ZR36057_JMC);
|
|
|
|
|
|
|
|
/* vertical */
|
|
|
|
btor(ZR36057_VFEVCR_VSPol, ZR36057_VFEVCR);
|
|
|
|
reg = (6 << ZR36057_VSP_VsyncSize) |
|
|
|
|
(tvn->Ht << ZR36057_VSP_FrmTot);
|
|
|
|
btwrite(reg, ZR36057_VSP);
|
|
|
|
reg = ((zr->jpg_settings.img_y + tvn->VStart) << ZR36057_FVAP_NAY) |
|
|
|
|
(zr->jpg_settings.img_height << ZR36057_FVAP_PAY);
|
|
|
|
btwrite(reg, ZR36057_FVAP);
|
|
|
|
|
|
|
|
/* horizontal */
|
|
|
|
if (zr->card.vfe_pol.hsync_pol)
|
|
|
|
btor(ZR36057_VFEHCR_HSPol, ZR36057_VFEHCR);
|
|
|
|
else
|
2006-03-25 12:19:53 +00:00
|
|
|
btand(~ZR36057_VFEHCR_HSPol, ZR36057_VFEHCR);
|
2005-04-16 22:20:36 +00:00
|
|
|
reg = ((tvn->HSyncStart) << ZR36057_HSP_HsyncStart) |
|
|
|
|
(tvn->Wt << ZR36057_HSP_LineTot);
|
|
|
|
btwrite(reg, ZR36057_HSP);
|
|
|
|
reg = ((zr->jpg_settings.img_x +
|
2006-03-25 12:19:53 +00:00
|
|
|
tvn->HStart + 4) << ZR36057_FHAP_NAX) |
|
2005-04-16 22:20:36 +00:00
|
|
|
(zr->jpg_settings.img_width << ZR36057_FHAP_PAX);
|
|
|
|
btwrite(reg, ZR36057_FHAP);
|
|
|
|
|
|
|
|
/* field process parameters */
|
|
|
|
if (zr->jpg_settings.odd_even)
|
|
|
|
reg = ZR36057_FPP_Odd_Even;
|
|
|
|
else
|
|
|
|
reg = 0;
|
|
|
|
|
|
|
|
btwrite(reg, ZR36057_FPP);
|
|
|
|
|
|
|
|
/* Set proper VCLK Polarity, else colors will be wrong during playback */
|
|
|
|
//btor(ZR36057_VFESPFR_VCLKPol, ZR36057_VFESPFR);
|
|
|
|
|
|
|
|
/* code base address */
|
|
|
|
reg = virt_to_bus(zr->stat_com);
|
|
|
|
btwrite(reg, ZR36057_JCBA);
|
|
|
|
|
|
|
|
/* FIFO threshold (FIFO is 160. double words) */
|
|
|
|
/* NOTE: decimal values here */
|
|
|
|
switch (mode) {
|
|
|
|
|
|
|
|
case BUZ_MODE_STILL_COMPRESS:
|
|
|
|
case BUZ_MODE_MOTION_COMPRESS:
|
|
|
|
if (zr->card.type != BUZ)
|
|
|
|
reg = 140;
|
|
|
|
else
|
|
|
|
reg = 60;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case BUZ_MODE_STILL_DECOMPRESS:
|
|
|
|
case BUZ_MODE_MOTION_DECOMPRESS:
|
|
|
|
reg = 20;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
reg = 80;
|
|
|
|
break;
|
|
|
|
|
|
|
|
}
|
|
|
|
btwrite(reg, ZR36057_JCFT);
|
|
|
|
zr36057_adjust_vfe(zr, mode);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
print_interrupts (struct zoran *zr)
|
|
|
|
{
|
|
|
|
int res, noerr = 0;
|
|
|
|
|
|
|
|
printk(KERN_INFO "%s: interrupts received:", ZR_DEVNAME(zr));
|
|
|
|
if ((res = zr->field_counter) < -1 || res > 1) {
|
2016-10-14 10:27:36 +00:00
|
|
|
printk(KERN_CONT " FD:%d", res);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
if ((res = zr->intr_counter_GIRQ1) != 0) {
|
2016-10-14 10:27:36 +00:00
|
|
|
printk(KERN_CONT " GIRQ1:%d", res);
|
2005-04-16 22:20:36 +00:00
|
|
|
noerr++;
|
|
|
|
}
|
|
|
|
if ((res = zr->intr_counter_GIRQ0) != 0) {
|
2016-10-14 10:27:36 +00:00
|
|
|
printk(KERN_CONT " GIRQ0:%d", res);
|
2005-04-16 22:20:36 +00:00
|
|
|
noerr++;
|
|
|
|
}
|
|
|
|
if ((res = zr->intr_counter_CodRepIRQ) != 0) {
|
2016-10-14 10:27:36 +00:00
|
|
|
printk(KERN_CONT " CodRepIRQ:%d", res);
|
2005-04-16 22:20:36 +00:00
|
|
|
noerr++;
|
|
|
|
}
|
|
|
|
if ((res = zr->intr_counter_JPEGRepIRQ) != 0) {
|
2016-10-14 10:27:36 +00:00
|
|
|
printk(KERN_CONT " JPEGRepIRQ:%d", res);
|
2005-04-16 22:20:36 +00:00
|
|
|
noerr++;
|
|
|
|
}
|
|
|
|
if (zr->JPEG_max_missed) {
|
2016-10-14 10:27:36 +00:00
|
|
|
printk(KERN_CONT " JPEG delays: max=%d min=%d", zr->JPEG_max_missed,
|
2005-04-16 22:20:36 +00:00
|
|
|
zr->JPEG_min_missed);
|
|
|
|
}
|
|
|
|
if (zr->END_event_missed) {
|
2016-10-14 10:27:36 +00:00
|
|
|
printk(KERN_CONT " ENDs missed: %d", zr->END_event_missed);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
//if (zr->jpg_queued_num) {
|
2016-10-14 10:27:36 +00:00
|
|
|
printk(KERN_CONT " queue_state=%ld/%ld/%ld/%ld", zr->jpg_que_tail,
|
2005-04-16 22:20:36 +00:00
|
|
|
zr->jpg_dma_tail, zr->jpg_dma_head, zr->jpg_que_head);
|
|
|
|
//}
|
|
|
|
if (!noerr) {
|
2016-10-14 10:27:36 +00:00
|
|
|
printk(KERN_CONT ": no interrupts detected.");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2016-10-14 10:27:36 +00:00
|
|
|
printk(KERN_CONT "\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
clear_interrupt_counters (struct zoran *zr)
|
|
|
|
{
|
|
|
|
zr->intr_counter_GIRQ1 = 0;
|
|
|
|
zr->intr_counter_GIRQ0 = 0;
|
|
|
|
zr->intr_counter_CodRepIRQ = 0;
|
|
|
|
zr->intr_counter_JPEGRepIRQ = 0;
|
|
|
|
zr->field_counter = 0;
|
|
|
|
zr->IRQ1_in = 0;
|
|
|
|
zr->IRQ1_out = 0;
|
|
|
|
zr->JPEG_in = 0;
|
|
|
|
zr->JPEG_out = 0;
|
|
|
|
zr->JPEG_0 = 0;
|
|
|
|
zr->JPEG_1 = 0;
|
|
|
|
zr->END_event_missed = 0;
|
|
|
|
zr->JPEG_missed = 0;
|
|
|
|
zr->JPEG_max_missed = 0;
|
|
|
|
zr->JPEG_min_missed = 0x7fffffff;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32
|
|
|
|
count_reset_interrupt (struct zoran *zr)
|
|
|
|
{
|
|
|
|
u32 isr;
|
|
|
|
|
|
|
|
if ((isr = btread(ZR36057_ISR) & 0x78000000)) {
|
|
|
|
if (isr & ZR36057_ISR_GIRQ1) {
|
|
|
|
btwrite(ZR36057_ISR_GIRQ1, ZR36057_ISR);
|
|
|
|
zr->intr_counter_GIRQ1++;
|
|
|
|
}
|
|
|
|
if (isr & ZR36057_ISR_GIRQ0) {
|
|
|
|
btwrite(ZR36057_ISR_GIRQ0, ZR36057_ISR);
|
|
|
|
zr->intr_counter_GIRQ0++;
|
|
|
|
}
|
|
|
|
if (isr & ZR36057_ISR_CodRepIRQ) {
|
|
|
|
btwrite(ZR36057_ISR_CodRepIRQ, ZR36057_ISR);
|
|
|
|
zr->intr_counter_CodRepIRQ++;
|
|
|
|
}
|
|
|
|
if (isr & ZR36057_ISR_JPEGRepIRQ) {
|
|
|
|
btwrite(ZR36057_ISR_JPEGRepIRQ, ZR36057_ISR);
|
|
|
|
zr->intr_counter_JPEGRepIRQ++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return isr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
jpeg_start (struct zoran *zr)
|
|
|
|
{
|
|
|
|
int reg;
|
|
|
|
|
|
|
|
zr->frame_num = 0;
|
|
|
|
|
|
|
|
/* deassert P_reset, disable code transfer, deassert Active */
|
|
|
|
btwrite(ZR36057_JPC_P_Reset, ZR36057_JPC);
|
|
|
|
/* stop flushing the internal code buffer */
|
|
|
|
btand(~ZR36057_MCTCR_CFlush, ZR36057_MCTCR);
|
|
|
|
/* enable code transfer */
|
|
|
|
btor(ZR36057_JPC_CodTrnsEn, ZR36057_JPC);
|
|
|
|
|
|
|
|
/* clear IRQs */
|
|
|
|
btwrite(IRQ_MASK, ZR36057_ISR);
|
|
|
|
/* enable the JPEG IRQs */
|
|
|
|
btwrite(zr->card.jpeg_int |
|
|
|
|
ZR36057_ICR_JPEGRepIRQ |
|
|
|
|
ZR36057_ICR_IntPinEn,
|
|
|
|
ZR36057_ICR);
|
|
|
|
|
|
|
|
set_frame(zr, 0); // \FRAME
|
|
|
|
|
|
|
|
/* set the JPEG codec guest ID */
|
|
|
|
reg = (zr->card.gpcs[1] << ZR36057_JCGI_JPEGuestID) |
|
|
|
|
(0 << ZR36057_JCGI_JPEGuestReg);
|
|
|
|
btwrite(reg, ZR36057_JCGI);
|
|
|
|
|
|
|
|
if (zr->card.video_vfe == CODEC_TYPE_ZR36016 &&
|
|
|
|
zr->card.video_codec == CODEC_TYPE_ZR36050) {
|
|
|
|
/* Enable processing on the ZR36016 */
|
|
|
|
if (zr->vfe)
|
|
|
|
zr36016_write(zr->vfe, 0, 1);
|
|
|
|
|
|
|
|
/* load the address of the GO register in the ZR36050 latch */
|
|
|
|
post_office_write(zr, 0, 0, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* assert Active */
|
|
|
|
btor(ZR36057_JPC_Active, ZR36057_JPC);
|
|
|
|
|
|
|
|
/* enable the Go generation */
|
|
|
|
btor(ZR36057_JMC_Go_en, ZR36057_JMC);
|
|
|
|
udelay(30);
|
|
|
|
|
|
|
|
set_frame(zr, 1); // /FRAME
|
|
|
|
|
|
|
|
dprintk(3, KERN_DEBUG "%s: jpeg_start\n", ZR_DEVNAME(zr));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
zr36057_enable_jpg (struct zoran *zr,
|
|
|
|
enum zoran_codec_mode mode)
|
|
|
|
{
|
|
|
|
struct vfe_settings cap;
|
|
|
|
int field_size =
|
|
|
|
zr->jpg_buffers.buffer_size / zr->jpg_settings.field_per_buff;
|
|
|
|
|
|
|
|
zr->codec_mode = mode;
|
|
|
|
|
|
|
|
cap.x = zr->jpg_settings.img_x;
|
|
|
|
cap.y = zr->jpg_settings.img_y;
|
|
|
|
cap.width = zr->jpg_settings.img_width;
|
|
|
|
cap.height = zr->jpg_settings.img_height;
|
|
|
|
cap.decimation =
|
|
|
|
zr->jpg_settings.HorDcm | (zr->jpg_settings.VerDcm << 8);
|
|
|
|
cap.quality = zr->jpg_settings.jpg_comp.quality;
|
|
|
|
|
|
|
|
switch (mode) {
|
|
|
|
|
|
|
|
case BUZ_MODE_MOTION_COMPRESS: {
|
|
|
|
struct jpeg_app_marker app;
|
|
|
|
struct jpeg_com_marker com;
|
|
|
|
|
|
|
|
/* In motion compress mode, the decoder output must be enabled, and
|
|
|
|
* the video bus direction set to input.
|
|
|
|
*/
|
|
|
|
set_videobus_dir(zr, 0);
|
2009-02-19 19:18:23 +00:00
|
|
|
decoder_call(zr, video, s_stream, 1);
|
2009-04-02 14:26:22 +00:00
|
|
|
encoder_call(zr, video, s_routing, 0, 0, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Take the JPEG codec and the VFE out of sleep */
|
|
|
|
jpeg_codec_sleep(zr, 0);
|
|
|
|
|
|
|
|
/* set JPEG app/com marker */
|
|
|
|
app.appn = zr->jpg_settings.jpg_comp.APPn;
|
|
|
|
app.len = zr->jpg_settings.jpg_comp.APP_len;
|
|
|
|
memcpy(app.data, zr->jpg_settings.jpg_comp.APP_data, 60);
|
|
|
|
zr->codec->control(zr->codec, CODEC_S_JPEG_APP_DATA,
|
|
|
|
sizeof(struct jpeg_app_marker), &app);
|
|
|
|
|
|
|
|
com.len = zr->jpg_settings.jpg_comp.COM_len;
|
|
|
|
memcpy(com.data, zr->jpg_settings.jpg_comp.COM_data, 60);
|
|
|
|
zr->codec->control(zr->codec, CODEC_S_JPEG_COM_DATA,
|
|
|
|
sizeof(struct jpeg_com_marker), &com);
|
|
|
|
|
|
|
|
/* Setup the JPEG codec */
|
|
|
|
zr->codec->control(zr->codec, CODEC_S_JPEG_TDS_BYTE,
|
|
|
|
sizeof(int), &field_size);
|
|
|
|
zr->codec->set_video(zr->codec, zr->timing, &cap,
|
|
|
|
&zr->card.vfe_pol);
|
|
|
|
zr->codec->set_mode(zr->codec, CODEC_DO_COMPRESSION);
|
|
|
|
|
|
|
|
/* Setup the VFE */
|
|
|
|
if (zr->vfe) {
|
|
|
|
zr->vfe->control(zr->vfe, CODEC_S_JPEG_TDS_BYTE,
|
|
|
|
sizeof(int), &field_size);
|
|
|
|
zr->vfe->set_video(zr->vfe, zr->timing, &cap,
|
|
|
|
&zr->card.vfe_pol);
|
|
|
|
zr->vfe->set_mode(zr->vfe, CODEC_DO_COMPRESSION);
|
|
|
|
}
|
|
|
|
|
|
|
|
init_jpeg_queue(zr);
|
|
|
|
zr36057_set_jpg(zr, mode); // \P_Reset, ... Video param, FIFO
|
|
|
|
|
|
|
|
clear_interrupt_counters(zr);
|
|
|
|
dprintk(2, KERN_INFO "%s: enable_jpg(MOTION_COMPRESS)\n",
|
|
|
|
ZR_DEVNAME(zr));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case BUZ_MODE_MOTION_DECOMPRESS:
|
|
|
|
/* In motion decompression mode, the decoder output must be disabled, and
|
|
|
|
* the video bus direction set to output.
|
|
|
|
*/
|
2009-02-19 19:18:23 +00:00
|
|
|
decoder_call(zr, video, s_stream, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
set_videobus_dir(zr, 1);
|
2009-04-02 14:26:22 +00:00
|
|
|
encoder_call(zr, video, s_routing, 1, 0, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Take the JPEG codec and the VFE out of sleep */
|
|
|
|
jpeg_codec_sleep(zr, 0);
|
|
|
|
/* Setup the VFE */
|
|
|
|
if (zr->vfe) {
|
|
|
|
zr->vfe->set_video(zr->vfe, zr->timing, &cap,
|
|
|
|
&zr->card.vfe_pol);
|
|
|
|
zr->vfe->set_mode(zr->vfe, CODEC_DO_EXPANSION);
|
|
|
|
}
|
|
|
|
/* Setup the JPEG codec */
|
|
|
|
zr->codec->set_video(zr->codec, zr->timing, &cap,
|
|
|
|
&zr->card.vfe_pol);
|
|
|
|
zr->codec->set_mode(zr->codec, CODEC_DO_EXPANSION);
|
|
|
|
|
|
|
|
init_jpeg_queue(zr);
|
|
|
|
zr36057_set_jpg(zr, mode); // \P_Reset, ... Video param, FIFO
|
|
|
|
|
|
|
|
clear_interrupt_counters(zr);
|
|
|
|
dprintk(2, KERN_INFO "%s: enable_jpg(MOTION_DECOMPRESS)\n",
|
|
|
|
ZR_DEVNAME(zr));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case BUZ_MODE_IDLE:
|
|
|
|
default:
|
|
|
|
/* shut down processing */
|
|
|
|
btand(~(zr->card.jpeg_int | ZR36057_ICR_JPEGRepIRQ),
|
|
|
|
ZR36057_ICR);
|
|
|
|
btwrite(zr->card.jpeg_int | ZR36057_ICR_JPEGRepIRQ,
|
|
|
|
ZR36057_ISR);
|
|
|
|
btand(~ZR36057_JMC_Go_en, ZR36057_JMC); // \Go_en
|
|
|
|
|
|
|
|
msleep(50);
|
|
|
|
|
|
|
|
set_videobus_dir(zr, 0);
|
|
|
|
set_frame(zr, 1); // /FRAME
|
|
|
|
btor(ZR36057_MCTCR_CFlush, ZR36057_MCTCR); // /CFlush
|
|
|
|
btwrite(0, ZR36057_JPC); // \P_Reset,\CodTrnsEn,\Active
|
|
|
|
btand(~ZR36057_JMC_VFIFO_FB, ZR36057_JMC);
|
|
|
|
btand(~ZR36057_JMC_SyncMstr, ZR36057_JMC);
|
|
|
|
jpeg_codec_reset(zr);
|
|
|
|
jpeg_codec_sleep(zr, 1);
|
|
|
|
zr36057_adjust_vfe(zr, mode);
|
|
|
|
|
2009-02-19 19:18:23 +00:00
|
|
|
decoder_call(zr, video, s_stream, 1);
|
2009-04-02 14:26:22 +00:00
|
|
|
encoder_call(zr, video, s_routing, 0, 0, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
dprintk(2, KERN_INFO "%s: enable_jpg(IDLE)\n", ZR_DEVNAME(zr));
|
|
|
|
break;
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* when this is called the spinlock must be held */
|
|
|
|
void
|
|
|
|
zoran_feed_stat_com (struct zoran *zr)
|
|
|
|
{
|
|
|
|
/* move frames from pending queue to DMA */
|
|
|
|
|
|
|
|
int frame, i, max_stat_com;
|
|
|
|
|
|
|
|
max_stat_com =
|
|
|
|
(zr->jpg_settings.TmpDcm ==
|
|
|
|
1) ? BUZ_NUM_STAT_COM : (BUZ_NUM_STAT_COM >> 1);
|
|
|
|
|
|
|
|
while ((zr->jpg_dma_head - zr->jpg_dma_tail) < max_stat_com &&
|
|
|
|
zr->jpg_dma_head < zr->jpg_que_head) {
|
|
|
|
|
|
|
|
frame = zr->jpg_pend[zr->jpg_dma_head & BUZ_MASK_FRAME];
|
|
|
|
if (zr->jpg_settings.TmpDcm == 1) {
|
|
|
|
/* fill 1 stat_com entry */
|
|
|
|
i = (zr->jpg_dma_head -
|
|
|
|
zr->jpg_err_shift) & BUZ_MASK_STAT_COM;
|
|
|
|
if (!(zr->stat_com[i] & cpu_to_le32(1)))
|
|
|
|
break;
|
|
|
|
zr->stat_com[i] =
|
2009-03-11 02:28:16 +00:00
|
|
|
cpu_to_le32(zr->jpg_buffers.buffer[frame].jpg.frag_tab_bus);
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
|
|
|
/* fill 2 stat_com entries */
|
|
|
|
i = ((zr->jpg_dma_head -
|
|
|
|
zr->jpg_err_shift) & 1) * 2;
|
|
|
|
if (!(zr->stat_com[i] & cpu_to_le32(1)))
|
|
|
|
break;
|
|
|
|
zr->stat_com[i] =
|
2009-03-11 02:28:16 +00:00
|
|
|
cpu_to_le32(zr->jpg_buffers.buffer[frame].jpg.frag_tab_bus);
|
2005-04-16 22:20:36 +00:00
|
|
|
zr->stat_com[i + 1] =
|
2009-03-11 02:28:16 +00:00
|
|
|
cpu_to_le32(zr->jpg_buffers.buffer[frame].jpg.frag_tab_bus);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
zr->jpg_buffers.buffer[frame].state = BUZ_STATE_DMA;
|
|
|
|
zr->jpg_dma_head++;
|
|
|
|
|
|
|
|
}
|
|
|
|
if (zr->codec_mode == BUZ_MODE_MOTION_DECOMPRESS)
|
|
|
|
zr->jpg_queued_num++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* when this is called the spinlock must be held */
|
|
|
|
static void
|
|
|
|
zoran_reap_stat_com (struct zoran *zr)
|
|
|
|
{
|
|
|
|
/* move frames from DMA queue to done queue */
|
|
|
|
|
|
|
|
int i;
|
|
|
|
u32 stat_com;
|
|
|
|
unsigned int seq;
|
|
|
|
unsigned int dif;
|
2009-03-11 02:28:16 +00:00
|
|
|
struct zoran_buffer *buffer;
|
2005-04-16 22:20:36 +00:00
|
|
|
int frame;
|
|
|
|
|
|
|
|
/* In motion decompress we don't have a hardware frame counter,
|
|
|
|
* we just count the interrupts here */
|
|
|
|
|
|
|
|
if (zr->codec_mode == BUZ_MODE_MOTION_DECOMPRESS) {
|
|
|
|
zr->jpg_seq_num++;
|
|
|
|
}
|
|
|
|
while (zr->jpg_dma_tail < zr->jpg_dma_head) {
|
|
|
|
if (zr->jpg_settings.TmpDcm == 1)
|
|
|
|
i = (zr->jpg_dma_tail -
|
|
|
|
zr->jpg_err_shift) & BUZ_MASK_STAT_COM;
|
|
|
|
else
|
|
|
|
i = ((zr->jpg_dma_tail -
|
|
|
|
zr->jpg_err_shift) & 1) * 2 + 1;
|
|
|
|
|
|
|
|
stat_com = le32_to_cpu(zr->stat_com[i]);
|
|
|
|
|
|
|
|
if ((stat_com & 1) == 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
frame = zr->jpg_pend[zr->jpg_dma_tail & BUZ_MASK_FRAME];
|
|
|
|
buffer = &zr->jpg_buffers.buffer[frame];
|
2012-09-15 18:14:42 +00:00
|
|
|
v4l2_get_timestamp(&buffer->bs.timestamp);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (zr->codec_mode == BUZ_MODE_MOTION_COMPRESS) {
|
|
|
|
buffer->bs.length = (stat_com & 0x7fffff) >> 1;
|
|
|
|
|
|
|
|
/* update sequence number with the help of the counter in stat_com */
|
|
|
|
|
|
|
|
seq = ((stat_com >> 24) + zr->jpg_err_seq) & 0xff;
|
|
|
|
dif = (seq - zr->jpg_seq_num) & 0xff;
|
|
|
|
zr->jpg_seq_num += dif;
|
|
|
|
} else {
|
|
|
|
buffer->bs.length = 0;
|
|
|
|
}
|
|
|
|
buffer->bs.seq =
|
|
|
|
zr->jpg_settings.TmpDcm ==
|
|
|
|
2 ? (zr->jpg_seq_num >> 1) : zr->jpg_seq_num;
|
|
|
|
buffer->state = BUZ_STATE_DONE;
|
|
|
|
|
|
|
|
zr->jpg_dma_tail++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-02-18 20:00:37 +00:00
|
|
|
static void zoran_restart(struct zoran *zr)
|
|
|
|
{
|
|
|
|
/* Now the stat_comm buffer is ready for restart */
|
2010-01-23 06:58:20 +00:00
|
|
|
unsigned int status = 0;
|
|
|
|
int mode;
|
2009-02-18 20:00:37 +00:00
|
|
|
|
|
|
|
if (zr->codec_mode == BUZ_MODE_MOTION_COMPRESS) {
|
2009-02-19 19:18:23 +00:00
|
|
|
decoder_call(zr, video, g_input_status, &status);
|
2009-02-18 20:00:37 +00:00
|
|
|
mode = CODEC_DO_COMPRESSION;
|
|
|
|
} else {
|
2009-02-18 20:26:06 +00:00
|
|
|
status = V4L2_IN_ST_NO_SIGNAL;
|
2009-02-18 20:00:37 +00:00
|
|
|
mode = CODEC_DO_EXPANSION;
|
|
|
|
}
|
|
|
|
if (zr->codec_mode == BUZ_MODE_MOTION_DECOMPRESS ||
|
2009-02-18 20:26:06 +00:00
|
|
|
!(status & V4L2_IN_ST_NO_SIGNAL)) {
|
2009-02-18 20:00:37 +00:00
|
|
|
/********** RESTART code *************/
|
|
|
|
jpeg_codec_reset(zr);
|
|
|
|
zr->codec->set_mode(zr->codec, mode);
|
|
|
|
zr36057_set_jpg(zr, zr->codec_mode);
|
|
|
|
jpeg_start(zr);
|
|
|
|
|
|
|
|
if (zr->num_errors <= 8)
|
|
|
|
dprintk(2, KERN_INFO "%s: Restart\n",
|
|
|
|
ZR_DEVNAME(zr));
|
|
|
|
|
|
|
|
zr->JPEG_missed = 0;
|
|
|
|
zr->JPEG_error = 2;
|
|
|
|
/********** End RESTART code ***********/
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static void
|
|
|
|
error_handler (struct zoran *zr,
|
|
|
|
u32 astat,
|
|
|
|
u32 stat)
|
|
|
|
{
|
2010-01-23 13:44:14 +00:00
|
|
|
int i;
|
2009-02-18 20:00:37 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* This is JPEG error handling part */
|
2009-02-18 20:00:37 +00:00
|
|
|
if (zr->codec_mode != BUZ_MODE_MOTION_COMPRESS &&
|
|
|
|
zr->codec_mode != BUZ_MODE_MOTION_DECOMPRESS) {
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((stat & 1) == 0 &&
|
|
|
|
zr->codec_mode == BUZ_MODE_MOTION_COMPRESS &&
|
2009-02-18 20:00:37 +00:00
|
|
|
zr->jpg_dma_tail - zr->jpg_que_tail >= zr->jpg_buffers.num_buffers) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/* No free buffers... */
|
|
|
|
zoran_reap_stat_com(zr);
|
|
|
|
zoran_feed_stat_com(zr);
|
|
|
|
wake_up_interruptible(&zr->jpg_capq);
|
|
|
|
zr->JPEG_missed = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-02-18 20:00:37 +00:00
|
|
|
if (zr->JPEG_error == 1) {
|
|
|
|
zoran_restart(zr);
|
|
|
|
return;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-02-18 20:00:37 +00:00
|
|
|
/*
|
|
|
|
* First entry: error just happened during normal operation
|
|
|
|
*
|
|
|
|
* In BUZ_MODE_MOTION_COMPRESS:
|
|
|
|
*
|
|
|
|
* Possible glitch in TV signal. In this case we should
|
|
|
|
* stop the codec and wait for good quality signal before
|
|
|
|
* restarting it to avoid further problems
|
|
|
|
*
|
|
|
|
* In BUZ_MODE_MOTION_DECOMPRESS:
|
|
|
|
*
|
|
|
|
* Bad JPEG frame: we have to mark it as processed (codec crashed
|
|
|
|
* and was not able to do it itself), and to remove it from queue.
|
|
|
|
*/
|
|
|
|
btand(~ZR36057_JMC_Go_en, ZR36057_JMC);
|
|
|
|
udelay(1);
|
|
|
|
stat = stat | (post_office_read(zr, 7, 0) & 3) << 8;
|
|
|
|
btwrite(0, ZR36057_JPC);
|
|
|
|
btor(ZR36057_MCTCR_CFlush, ZR36057_MCTCR);
|
|
|
|
jpeg_codec_reset(zr);
|
|
|
|
jpeg_codec_sleep(zr, 1);
|
|
|
|
zr->JPEG_error = 1;
|
|
|
|
zr->num_errors++;
|
|
|
|
|
|
|
|
/* Report error */
|
|
|
|
if (zr36067_debug > 1 && zr->num_errors <= 8) {
|
|
|
|
long frame;
|
2010-01-23 13:44:14 +00:00
|
|
|
int j;
|
2009-02-18 20:00:37 +00:00
|
|
|
|
|
|
|
frame = zr->jpg_pend[zr->jpg_dma_tail & BUZ_MASK_FRAME];
|
|
|
|
printk(KERN_ERR
|
|
|
|
"%s: JPEG error stat=0x%08x(0x%08x) queue_state=%ld/%ld/%ld/%ld seq=%ld frame=%ld. Codec stopped. ",
|
|
|
|
ZR_DEVNAME(zr), stat, zr->last_isr,
|
|
|
|
zr->jpg_que_tail, zr->jpg_dma_tail,
|
|
|
|
zr->jpg_dma_head, zr->jpg_que_head,
|
|
|
|
zr->jpg_seq_num, frame);
|
|
|
|
printk(KERN_INFO "stat_com frames:");
|
|
|
|
for (j = 0; j < BUZ_NUM_STAT_COM; j++) {
|
|
|
|
for (i = 0; i < zr->jpg_buffers.num_buffers; i++) {
|
2009-03-11 02:28:16 +00:00
|
|
|
if (le32_to_cpu(zr->stat_com[j]) == zr->jpg_buffers.buffer[i].jpg.frag_tab_bus)
|
2009-02-18 20:00:37 +00:00
|
|
|
printk(KERN_CONT "% d->%d", j, i);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
2009-02-18 20:00:37 +00:00
|
|
|
printk(KERN_CONT "\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2009-02-18 20:00:37 +00:00
|
|
|
/* Find an entry in stat_com and rotate contents */
|
|
|
|
if (zr->jpg_settings.TmpDcm == 1)
|
|
|
|
i = (zr->jpg_dma_tail - zr->jpg_err_shift) & BUZ_MASK_STAT_COM;
|
|
|
|
else
|
|
|
|
i = ((zr->jpg_dma_tail - zr->jpg_err_shift) & 1) * 2;
|
|
|
|
if (zr->codec_mode == BUZ_MODE_MOTION_DECOMPRESS) {
|
|
|
|
/* Mimic zr36067 operation */
|
|
|
|
zr->stat_com[i] |= cpu_to_le32(1);
|
|
|
|
if (zr->jpg_settings.TmpDcm != 1)
|
|
|
|
zr->stat_com[i + 1] |= cpu_to_le32(1);
|
|
|
|
/* Refill */
|
|
|
|
zoran_reap_stat_com(zr);
|
|
|
|
zoran_feed_stat_com(zr);
|
|
|
|
wake_up_interruptible(&zr->jpg_capq);
|
|
|
|
/* Find an entry in stat_com again after refill */
|
|
|
|
if (zr->jpg_settings.TmpDcm == 1)
|
|
|
|
i = (zr->jpg_dma_tail - zr->jpg_err_shift) & BUZ_MASK_STAT_COM;
|
|
|
|
else
|
|
|
|
i = ((zr->jpg_dma_tail - zr->jpg_err_shift) & 1) * 2;
|
|
|
|
}
|
|
|
|
if (i) {
|
|
|
|
/* Rotate stat_comm entries to make current entry first */
|
|
|
|
int j;
|
|
|
|
__le32 bus_addr[BUZ_NUM_STAT_COM];
|
|
|
|
|
|
|
|
/* Here we are copying the stat_com array, which
|
|
|
|
* is already in little endian format, so
|
|
|
|
* no endian conversions here
|
|
|
|
*/
|
|
|
|
memcpy(bus_addr, zr->stat_com, sizeof(bus_addr));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-02-18 20:00:37 +00:00
|
|
|
for (j = 0; j < BUZ_NUM_STAT_COM; j++)
|
|
|
|
zr->stat_com[j] = bus_addr[(i + j) & BUZ_MASK_STAT_COM];
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-02-18 20:00:37 +00:00
|
|
|
zr->jpg_err_shift += i;
|
|
|
|
zr->jpg_err_shift &= BUZ_MASK_STAT_COM;
|
|
|
|
}
|
|
|
|
if (zr->codec_mode == BUZ_MODE_MOTION_COMPRESS)
|
|
|
|
zr->jpg_err_seq = zr->jpg_seq_num; /* + 1; */
|
|
|
|
zoran_restart(zr);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
irqreturn_t
|
|
|
|
zoran_irq (int irq,
|
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
|
|
|
void *dev_id)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
u32 stat, astat;
|
|
|
|
int count;
|
|
|
|
struct zoran *zr;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2006-10-06 19:00:58 +00:00
|
|
|
zr = dev_id;
|
2005-04-16 22:20:36 +00:00
|
|
|
count = 0;
|
|
|
|
|
|
|
|
if (zr->testing) {
|
|
|
|
/* Testing interrupts */
|
|
|
|
spin_lock_irqsave(&zr->spinlock, flags);
|
|
|
|
while ((stat = count_reset_interrupt(zr))) {
|
|
|
|
if (count++ > 100) {
|
|
|
|
btand(~ZR36057_ICR_IntPinEn, ZR36057_ICR);
|
|
|
|
dprintk(1,
|
|
|
|
KERN_ERR
|
|
|
|
"%s: IRQ lockup while testing, isr=0x%08x, cleared int mask\n",
|
|
|
|
ZR_DEVNAME(zr), stat);
|
|
|
|
wake_up_interruptible(&zr->test_q);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
zr->last_isr = stat;
|
|
|
|
spin_unlock_irqrestore(&zr->spinlock, flags);
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_irqsave(&zr->spinlock, flags);
|
|
|
|
while (1) {
|
|
|
|
/* get/clear interrupt status bits */
|
|
|
|
stat = count_reset_interrupt(zr);
|
|
|
|
astat = stat & IRQ_MASK;
|
|
|
|
if (!astat) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
dprintk(4,
|
|
|
|
KERN_DEBUG
|
|
|
|
"zoran_irq: astat: 0x%08x, mask: 0x%08x\n",
|
|
|
|
astat, btread(ZR36057_ICR));
|
|
|
|
if (astat & zr->card.vsync_int) { // SW
|
|
|
|
|
|
|
|
if (zr->codec_mode == BUZ_MODE_MOTION_DECOMPRESS ||
|
|
|
|
zr->codec_mode == BUZ_MODE_MOTION_COMPRESS) {
|
|
|
|
/* count missed interrupts */
|
|
|
|
zr->JPEG_missed++;
|
|
|
|
}
|
|
|
|
//post_office_read(zr,1,0);
|
|
|
|
/* Interrupts may still happen when
|
|
|
|
* zr->v4l_memgrab_active is switched off.
|
|
|
|
* We simply ignore them */
|
|
|
|
|
|
|
|
if (zr->v4l_memgrab_active) {
|
|
|
|
/* A lot more checks should be here ... */
|
2009-02-18 20:00:37 +00:00
|
|
|
if ((btread(ZR36057_VSSFGR) & ZR36057_VSSFGR_SnapShot) == 0)
|
2005-04-16 22:20:36 +00:00
|
|
|
dprintk(1,
|
|
|
|
KERN_WARNING
|
|
|
|
"%s: BuzIRQ with SnapShot off ???\n",
|
|
|
|
ZR_DEVNAME(zr));
|
|
|
|
|
|
|
|
if (zr->v4l_grab_frame != NO_GRAB_ACTIVE) {
|
|
|
|
/* There is a grab on a frame going on, check if it has finished */
|
2009-02-18 20:00:37 +00:00
|
|
|
if ((btread(ZR36057_VSSFGR) & ZR36057_VSSFGR_FrameGrab) == 0) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/* it is finished, notify the user */
|
|
|
|
|
|
|
|
zr->v4l_buffers.buffer[zr->v4l_grab_frame].state = BUZ_STATE_DONE;
|
|
|
|
zr->v4l_buffers.buffer[zr->v4l_grab_frame].bs.seq = zr->v4l_grab_seq;
|
2012-09-15 18:14:42 +00:00
|
|
|
v4l2_get_timestamp(&zr->v4l_buffers.buffer[zr->v4l_grab_frame].bs.timestamp);
|
2005-04-16 22:20:36 +00:00
|
|
|
zr->v4l_grab_frame = NO_GRAB_ACTIVE;
|
|
|
|
zr->v4l_pend_tail++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (zr->v4l_grab_frame == NO_GRAB_ACTIVE)
|
|
|
|
wake_up_interruptible(&zr->v4l_capq);
|
|
|
|
|
|
|
|
/* Check if there is another grab queued */
|
|
|
|
|
|
|
|
if (zr->v4l_grab_frame == NO_GRAB_ACTIVE &&
|
|
|
|
zr->v4l_pend_tail != zr->v4l_pend_head) {
|
2009-02-18 20:00:37 +00:00
|
|
|
int frame = zr->v4l_pend[zr->v4l_pend_tail & V4L_MASK_FRAME];
|
2005-04-16 22:20:36 +00:00
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
zr->v4l_grab_frame = frame;
|
|
|
|
|
|
|
|
/* Set zr36057 video front end and enable video */
|
|
|
|
|
|
|
|
/* Buffer address */
|
|
|
|
|
2009-03-11 02:28:16 +00:00
|
|
|
reg = zr->v4l_buffers.buffer[frame].v4l.fbuffer_bus;
|
2005-04-16 22:20:36 +00:00
|
|
|
btwrite(reg, ZR36057_VDTR);
|
2009-02-18 20:00:37 +00:00
|
|
|
if (zr->v4l_settings.height > BUZ_MAX_HEIGHT / 2)
|
|
|
|
reg += zr->v4l_settings.bytesperline;
|
2005-04-16 22:20:36 +00:00
|
|
|
btwrite(reg, ZR36057_VDBR);
|
|
|
|
|
|
|
|
/* video stride, status, and frame grab register */
|
|
|
|
reg = 0;
|
2009-02-18 20:00:37 +00:00
|
|
|
if (zr->v4l_settings.height > BUZ_MAX_HEIGHT / 2)
|
|
|
|
reg += zr->v4l_settings.bytesperline;
|
|
|
|
reg = (reg << ZR36057_VSSFGR_DispStride);
|
2005-04-16 22:20:36 +00:00
|
|
|
reg |= ZR36057_VSSFGR_VidOvf;
|
|
|
|
reg |= ZR36057_VSSFGR_SnapShot;
|
|
|
|
reg |= ZR36057_VSSFGR_FrameGrab;
|
|
|
|
btwrite(reg, ZR36057_VSSFGR);
|
|
|
|
|
|
|
|
btor(ZR36057_VDCR_VidEn,
|
|
|
|
ZR36057_VDCR);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* even if we don't grab, we do want to increment
|
|
|
|
* the sequence counter to see lost frames */
|
|
|
|
zr->v4l_grab_seq++;
|
|
|
|
}
|
|
|
|
#if (IRQ_MASK & ZR36057_ISR_CodRepIRQ)
|
|
|
|
if (astat & ZR36057_ISR_CodRepIRQ) {
|
|
|
|
zr->intr_counter_CodRepIRQ++;
|
2009-02-18 20:00:37 +00:00
|
|
|
IDEBUG(printk(KERN_DEBUG "%s: ZR36057_ISR_CodRepIRQ\n",
|
2005-04-16 22:20:36 +00:00
|
|
|
ZR_DEVNAME(zr)));
|
|
|
|
btand(~ZR36057_ICR_CodRepIRQ, ZR36057_ICR);
|
|
|
|
}
|
|
|
|
#endif /* (IRQ_MASK & ZR36057_ISR_CodRepIRQ) */
|
|
|
|
|
|
|
|
#if (IRQ_MASK & ZR36057_ISR_JPEGRepIRQ)
|
2009-02-18 20:00:37 +00:00
|
|
|
if ((astat & ZR36057_ISR_JPEGRepIRQ) &&
|
|
|
|
(zr->codec_mode == BUZ_MODE_MOTION_DECOMPRESS ||
|
|
|
|
zr->codec_mode == BUZ_MODE_MOTION_COMPRESS)) {
|
|
|
|
if (zr36067_debug > 1 && (!zr->frame_num || zr->JPEG_error)) {
|
2010-09-13 22:07:14 +00:00
|
|
|
char sv[BUZ_NUM_STAT_COM + 1];
|
2009-02-18 20:00:37 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
printk(KERN_INFO
|
|
|
|
"%s: first frame ready: state=0x%08x odd_even=%d field_per_buff=%d delay=%d\n",
|
|
|
|
ZR_DEVNAME(zr), stat,
|
|
|
|
zr->jpg_settings.odd_even,
|
|
|
|
zr->jpg_settings.field_per_buff,
|
|
|
|
zr->JPEG_missed);
|
|
|
|
|
2010-09-13 22:07:14 +00:00
|
|
|
for (i = 0; i < BUZ_NUM_STAT_COM; i++)
|
|
|
|
sv[i] = le32_to_cpu(zr->stat_com[i]) & 1 ? '1' : '0';
|
|
|
|
sv[BUZ_NUM_STAT_COM] = 0;
|
2009-02-18 20:00:37 +00:00
|
|
|
printk(KERN_INFO
|
|
|
|
"%s: stat_com=%s queue_state=%ld/%ld/%ld/%ld\n",
|
|
|
|
ZR_DEVNAME(zr), sv,
|
|
|
|
zr->jpg_que_tail,
|
|
|
|
zr->jpg_dma_tail,
|
|
|
|
zr->jpg_dma_head,
|
|
|
|
zr->jpg_que_head);
|
|
|
|
} else {
|
|
|
|
/* Get statistics */
|
|
|
|
if (zr->JPEG_missed > zr->JPEG_max_missed)
|
|
|
|
zr->JPEG_max_missed = zr->JPEG_missed;
|
|
|
|
if (zr->JPEG_missed < zr->JPEG_min_missed)
|
|
|
|
zr->JPEG_min_missed = zr->JPEG_missed;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-02-18 20:00:37 +00:00
|
|
|
if (zr36067_debug > 2 && zr->frame_num < 6) {
|
|
|
|
int i;
|
|
|
|
|
|
|
|
printk(KERN_INFO "%s: seq=%ld stat_com:",
|
|
|
|
ZR_DEVNAME(zr), zr->jpg_seq_num);
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
printk(KERN_CONT " %08x",
|
|
|
|
le32_to_cpu(zr->stat_com[i]));
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2009-02-18 20:00:37 +00:00
|
|
|
printk(KERN_CONT "\n");
|
|
|
|
}
|
|
|
|
zr->frame_num++;
|
|
|
|
zr->JPEG_missed = 0;
|
|
|
|
zr->JPEG_error = 0;
|
|
|
|
zoran_reap_stat_com(zr);
|
|
|
|
zoran_feed_stat_com(zr);
|
|
|
|
wake_up_interruptible(&zr->jpg_capq);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
#endif /* (IRQ_MASK & ZR36057_ISR_JPEGRepIRQ) */
|
|
|
|
|
|
|
|
/* DATERR, too many fields missed, error processing */
|
|
|
|
if ((astat & zr->card.jpeg_int) ||
|
|
|
|
zr->JPEG_missed > 25 ||
|
|
|
|
zr->JPEG_error == 1 ||
|
|
|
|
((zr->codec_mode == BUZ_MODE_MOTION_DECOMPRESS) &&
|
2010-12-10 12:39:34 +00:00
|
|
|
(zr->frame_num && (zr->JPEG_missed > zr->jpg_settings.field_per_buff)))) {
|
2005-04-16 22:20:36 +00:00
|
|
|
error_handler(zr, astat, stat);
|
|
|
|
}
|
|
|
|
|
|
|
|
count++;
|
|
|
|
if (count > 10) {
|
|
|
|
dprintk(2, KERN_WARNING "%s: irq loop %d\n",
|
|
|
|
ZR_DEVNAME(zr), count);
|
|
|
|
if (count > 20) {
|
|
|
|
btand(~ZR36057_ICR_IntPinEn, ZR36057_ICR);
|
|
|
|
dprintk(2,
|
|
|
|
KERN_ERR
|
|
|
|
"%s: IRQ lockup, cleared int mask\n",
|
|
|
|
ZR_DEVNAME(zr));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
zr->last_isr = stat;
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&zr->spinlock, flags);
|
|
|
|
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
zoran_set_pci_master (struct zoran *zr,
|
|
|
|
int set_master)
|
|
|
|
{
|
|
|
|
if (set_master) {
|
|
|
|
pci_set_master(zr->pci_dev);
|
|
|
|
} else {
|
|
|
|
u16 command;
|
|
|
|
|
|
|
|
pci_read_config_word(zr->pci_dev, PCI_COMMAND, &command);
|
|
|
|
command &= ~PCI_COMMAND_MASTER;
|
|
|
|
pci_write_config_word(zr->pci_dev, PCI_COMMAND, command);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
zoran_init_hardware (struct zoran *zr)
|
|
|
|
{
|
|
|
|
/* Enable bus-mastering */
|
|
|
|
zoran_set_pci_master(zr, 1);
|
|
|
|
|
|
|
|
/* Initialize the board */
|
|
|
|
if (zr->card.init) {
|
|
|
|
zr->card.init(zr);
|
|
|
|
}
|
|
|
|
|
2009-02-19 19:18:23 +00:00
|
|
|
decoder_call(zr, core, init, 0);
|
2014-04-28 19:53:01 +00:00
|
|
|
decoder_call(zr, video, s_std, zr->norm);
|
2009-04-02 14:26:22 +00:00
|
|
|
decoder_call(zr, video, s_routing,
|
|
|
|
zr->card.input[zr->input].muxsel, 0, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-02-19 19:18:23 +00:00
|
|
|
encoder_call(zr, core, init, 0);
|
|
|
|
encoder_call(zr, video, s_std_output, zr->norm);
|
2009-04-02 14:26:22 +00:00
|
|
|
encoder_call(zr, video, s_routing, 0, 0, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* toggle JPEG codec sleep to sync PLL */
|
|
|
|
jpeg_codec_sleep(zr, 1);
|
|
|
|
jpeg_codec_sleep(zr, 0);
|
|
|
|
|
2015-04-28 14:13:09 +00:00
|
|
|
/*
|
|
|
|
* set individual interrupt enables (without GIRQ1)
|
|
|
|
* but don't global enable until zoran_open()
|
|
|
|
*/
|
|
|
|
zr36057_init_vfe(zr);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
zr36057_enable_jpg(zr, BUZ_MODE_IDLE);
|
|
|
|
|
|
|
|
btwrite(IRQ_MASK, ZR36057_ISR); // Clears interrupts
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
zr36057_restart (struct zoran *zr)
|
|
|
|
{
|
|
|
|
btwrite(0, ZR36057_SPGPPCR);
|
|
|
|
mdelay(1);
|
|
|
|
btor(ZR36057_SPGPPCR_SoftReset, ZR36057_SPGPPCR);
|
|
|
|
mdelay(1);
|
|
|
|
|
|
|
|
/* assert P_Reset */
|
|
|
|
btwrite(0, ZR36057_JPC);
|
|
|
|
/* set up GPIO direction - all output */
|
|
|
|
btwrite(ZR36057_SPGPPCR_SoftReset | 0, ZR36057_SPGPPCR);
|
|
|
|
|
|
|
|
/* set up GPIO pins and guest bus timing */
|
|
|
|
btwrite((0x81 << 24) | 0x8888, ZR36057_GPPGCR1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* initialize video front end
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
zr36057_init_vfe (struct zoran *zr)
|
|
|
|
{
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
reg = btread(ZR36057_VFESPFR);
|
|
|
|
reg |= ZR36057_VFESPFR_LittleEndian;
|
|
|
|
reg &= ~ZR36057_VFESPFR_VCLKPol;
|
|
|
|
reg |= ZR36057_VFESPFR_ExtFl;
|
|
|
|
reg |= ZR36057_VFESPFR_TopField;
|
|
|
|
btwrite(reg, ZR36057_VFESPFR);
|
|
|
|
reg = btread(ZR36057_VDCR);
|
|
|
|
if (pci_pci_problems & PCIPCI_TRITON)
|
|
|
|
// || zr->revision < 1) // Revision 1 has also Triton support
|
|
|
|
reg &= ~ZR36057_VDCR_Triton;
|
|
|
|
else
|
|
|
|
reg |= ZR36057_VDCR_Triton;
|
|
|
|
btwrite(reg, ZR36057_VDCR);
|
|
|
|
}
|