mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-11 08:06:39 +07:00
18f3fa1e2e
Some includes were added after some non-include macros, on old drivers. Better to keep all includes at the beginning of the files. This change also helps to make backports to properly work at the development tree. Signed-off-by: Mauro Carvalho Chehab <mchehab@infradead.org>
1217 lines
31 KiB
C
1217 lines
31 KiB
C
/*
|
|
* saa7114 - Philips SAA7114H video decoder driver version 0.0.1
|
|
*
|
|
* Copyright (C) 2002 Maxim Yevtyushkin <max@linuxmedialabs.com>
|
|
*
|
|
* Based on saa7111 driver by Dave Perks
|
|
*
|
|
* Copyright (C) 1998 Dave Perks <dperks@ibm.net>
|
|
*
|
|
* Slight changes for video timing and attachment output by
|
|
* Wolfgang Scherr <scherr@net4you.net>
|
|
*
|
|
* Changes by Ronald Bultje <rbultje@ronald.bitfreak.net>
|
|
* - moved over to linux>=2.4.x i2c protocol (1/1/2003)
|
|
*
|
|
* 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.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/init.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/major.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/signal.h>
|
|
#include <linux/types.h>
|
|
#include <linux/i2c.h>
|
|
#include <asm/io.h>
|
|
#include <asm/pgtable.h>
|
|
#include <asm/page.h>
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <linux/videodev.h>
|
|
#include <linux/video_decoder.h>
|
|
|
|
MODULE_DESCRIPTION("Philips SAA7114H video decoder driver");
|
|
MODULE_AUTHOR("Maxim Yevtyushkin");
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
|
#define I2C_NAME(x) (x)->name
|
|
|
|
|
|
static int debug = 0;
|
|
module_param(debug, int, 0);
|
|
MODULE_PARM_DESC(debug, "Debug level (0-1)");
|
|
|
|
#define dprintk(num, format, args...) \
|
|
do { \
|
|
if (debug >= num) \
|
|
printk(format, ##args); \
|
|
} while (0)
|
|
|
|
/* ----------------------------------------------------------------------- */
|
|
|
|
struct saa7114 {
|
|
unsigned char reg[0xf0 * 2];
|
|
|
|
int norm;
|
|
int input;
|
|
int enable;
|
|
int bright;
|
|
int contrast;
|
|
int hue;
|
|
int sat;
|
|
int playback;
|
|
};
|
|
|
|
#define I2C_SAA7114 0x42
|
|
#define I2C_SAA7114A 0x40
|
|
|
|
#define I2C_DELAY 10
|
|
|
|
|
|
//#define SAA_7114_NTSC_HSYNC_START (-3)
|
|
//#define SAA_7114_NTSC_HSYNC_STOP (-18)
|
|
|
|
#define SAA_7114_NTSC_HSYNC_START (-17)
|
|
#define SAA_7114_NTSC_HSYNC_STOP (-32)
|
|
|
|
//#define SAA_7114_NTSC_HOFFSET (5)
|
|
#define SAA_7114_NTSC_HOFFSET (6)
|
|
#define SAA_7114_NTSC_VOFFSET (10)
|
|
#define SAA_7114_NTSC_WIDTH (720)
|
|
#define SAA_7114_NTSC_HEIGHT (250)
|
|
|
|
#define SAA_7114_SECAM_HSYNC_START (-17)
|
|
#define SAA_7114_SECAM_HSYNC_STOP (-32)
|
|
|
|
#define SAA_7114_SECAM_HOFFSET (2)
|
|
#define SAA_7114_SECAM_VOFFSET (10)
|
|
#define SAA_7114_SECAM_WIDTH (720)
|
|
#define SAA_7114_SECAM_HEIGHT (300)
|
|
|
|
#define SAA_7114_PAL_HSYNC_START (-17)
|
|
#define SAA_7114_PAL_HSYNC_STOP (-32)
|
|
|
|
#define SAA_7114_PAL_HOFFSET (2)
|
|
#define SAA_7114_PAL_VOFFSET (10)
|
|
#define SAA_7114_PAL_WIDTH (720)
|
|
#define SAA_7114_PAL_HEIGHT (300)
|
|
|
|
|
|
|
|
#define SAA_7114_VERTICAL_CHROMA_OFFSET 0 //0x50504040
|
|
#define SAA_7114_VERTICAL_LUMA_OFFSET 0
|
|
|
|
#define REG_ADDR(x) (((x) << 1) + 1)
|
|
#define LOBYTE(x) ((unsigned char)((x) & 0xff))
|
|
#define HIBYTE(x) ((unsigned char)(((x) >> 8) & 0xff))
|
|
#define LOWORD(x) ((unsigned short int)((x) & 0xffff))
|
|
#define HIWORD(x) ((unsigned short int)(((x) >> 16) & 0xffff))
|
|
|
|
|
|
/* ----------------------------------------------------------------------- */
|
|
|
|
static inline int
|
|
saa7114_write (struct i2c_client *client,
|
|
u8 reg,
|
|
u8 value)
|
|
{
|
|
return i2c_smbus_write_byte_data(client, reg, value);
|
|
}
|
|
|
|
static int
|
|
saa7114_write_block (struct i2c_client *client,
|
|
const u8 *data,
|
|
unsigned int len)
|
|
{
|
|
int ret = -1;
|
|
u8 reg;
|
|
|
|
/* the saa7114 has an autoincrement function, use it if
|
|
* the adapter understands raw I2C */
|
|
if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
|
|
/* do raw I2C, not smbus compatible */
|
|
u8 block_data[32];
|
|
int block_len;
|
|
|
|
while (len >= 2) {
|
|
block_len = 0;
|
|
block_data[block_len++] = reg = data[0];
|
|
do {
|
|
block_data[block_len++] = data[1];
|
|
reg++;
|
|
len -= 2;
|
|
data += 2;
|
|
} while (len >= 2 && data[0] == reg &&
|
|
block_len < 32);
|
|
if ((ret = i2c_master_send(client, block_data,
|
|
block_len)) < 0)
|
|
break;
|
|
}
|
|
} else {
|
|
/* do some slow I2C emulation kind of thing */
|
|
while (len >= 2) {
|
|
reg = *data++;
|
|
if ((ret = saa7114_write(client, reg,
|
|
*data++)) < 0)
|
|
break;
|
|
len -= 2;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static inline int
|
|
saa7114_read (struct i2c_client *client,
|
|
u8 reg)
|
|
{
|
|
return i2c_smbus_read_byte_data(client, reg);
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------- */
|
|
|
|
// initially set NTSC, composite
|
|
|
|
|
|
static const unsigned char init[] = {
|
|
0x00, 0x00, /* 00 - ID byte , chip version,
|
|
* read only */
|
|
0x01, 0x08, /* 01 - X,X,X,X, IDEL3 to IDEL0 -
|
|
* horizontal increment delay,
|
|
* recommended position */
|
|
0x02, 0x00, /* 02 - FUSE=3, GUDL=2, MODE=0 ;
|
|
* input control */
|
|
0x03, 0x10, /* 03 - HLNRS=0, VBSL=1, WPOFF=0,
|
|
* HOLDG=0, GAFIX=0, GAI1=256, GAI2=256 */
|
|
0x04, 0x90, /* 04 - GAI1=256 */
|
|
0x05, 0x90, /* 05 - GAI2=256 */
|
|
0x06, SAA_7114_NTSC_HSYNC_START, /* 06 - HSB: hsync start,
|
|
* depends on the video standard */
|
|
0x07, SAA_7114_NTSC_HSYNC_STOP, /* 07 - HSS: hsync stop, depends
|
|
*on the video standard */
|
|
0x08, 0xb8, /* 08 - AUFD=1, FSEL=1, EXFIL=0, VTRC=1,
|
|
* HPLL: free running in playback, locked
|
|
* in capture, VNOI=0 */
|
|
0x09, 0x80, /* 09 - BYPS=0, PREF=0, BPSS=0, VBLB=0,
|
|
* UPTCV=0, APER=1; depends from input */
|
|
0x0a, 0x80, /* 0a - BRIG=128 */
|
|
0x0b, 0x44, /* 0b - CONT=1.109 */
|
|
0x0c, 0x40, /* 0c - SATN=1.0 */
|
|
0x0d, 0x00, /* 0d - HUE=0 */
|
|
0x0e, 0x84, /* 0e - CDTO, CSTD2 to 0, DCVF, FCTC,
|
|
* CCOMB; depends from video standard */
|
|
0x0f, 0x24, /* 0f - ACGC,CGAIN6 to CGAIN0; depends
|
|
* from video standard */
|
|
0x10, 0x03, /* 10 - OFFU1 to 0, OFFV1 to 0, CHBW,
|
|
* LCBW2 to 0 */
|
|
0x11, 0x59, /* 11 - COLO, RTP1, HEDL1 to 0, RTP0,
|
|
* YDEL2 to 0 */
|
|
0x12, 0xc9, /* 12 - RT signal control RTSE13 to 10
|
|
* and 03 to 00 */
|
|
0x13, 0x80, /* 13 - RT/X port output control */
|
|
0x14, 0x00, /* 14 - analog, ADC, compatibility control */
|
|
0x15, 0x00, /* 15 - VGATE start FID change */
|
|
0x16, 0xfe, /* 16 - VGATE stop */
|
|
0x17, 0x00, /* 17 - Misc., VGATE MSBs */
|
|
0x18, 0x40, /* RAWG */
|
|
0x19, 0x80, /* RAWO */
|
|
0x1a, 0x00,
|
|
0x1b, 0x00,
|
|
0x1c, 0x00,
|
|
0x1d, 0x00,
|
|
0x1e, 0x00,
|
|
0x1f, 0x00, /* status byte, read only */
|
|
0x20, 0x00, /* video decoder reserved part */
|
|
0x21, 0x00,
|
|
0x22, 0x00,
|
|
0x23, 0x00,
|
|
0x24, 0x00,
|
|
0x25, 0x00,
|
|
0x26, 0x00,
|
|
0x27, 0x00,
|
|
0x28, 0x00,
|
|
0x29, 0x00,
|
|
0x2a, 0x00,
|
|
0x2b, 0x00,
|
|
0x2c, 0x00,
|
|
0x2d, 0x00,
|
|
0x2e, 0x00,
|
|
0x2f, 0x00,
|
|
0x30, 0xbc, /* audio clock generator */
|
|
0x31, 0xdf,
|
|
0x32, 0x02,
|
|
0x33, 0x00,
|
|
0x34, 0xcd,
|
|
0x35, 0xcc,
|
|
0x36, 0x3a,
|
|
0x37, 0x00,
|
|
0x38, 0x03,
|
|
0x39, 0x10,
|
|
0x3a, 0x00,
|
|
0x3b, 0x00,
|
|
0x3c, 0x00,
|
|
0x3d, 0x00,
|
|
0x3e, 0x00,
|
|
0x3f, 0x00,
|
|
0x40, 0x00, /* VBI data slicer */
|
|
0x41, 0xff,
|
|
0x42, 0xff,
|
|
0x43, 0xff,
|
|
0x44, 0xff,
|
|
0x45, 0xff,
|
|
0x46, 0xff,
|
|
0x47, 0xff,
|
|
0x48, 0xff,
|
|
0x49, 0xff,
|
|
0x4a, 0xff,
|
|
0x4b, 0xff,
|
|
0x4c, 0xff,
|
|
0x4d, 0xff,
|
|
0x4e, 0xff,
|
|
0x4f, 0xff,
|
|
0x50, 0xff,
|
|
0x51, 0xff,
|
|
0x52, 0xff,
|
|
0x53, 0xff,
|
|
0x54, 0xff,
|
|
0x55, 0xff,
|
|
0x56, 0xff,
|
|
0x57, 0xff,
|
|
0x58, 0x40, // framing code
|
|
0x59, 0x47, // horizontal offset
|
|
0x5a, 0x06, // vertical offset
|
|
0x5b, 0x83, // field offset
|
|
0x5c, 0x00, // reserved
|
|
0x5d, 0x3e, // header and data
|
|
0x5e, 0x00, // sliced data
|
|
0x5f, 0x00, // reserved
|
|
0x60, 0x00, /* video decoder reserved part */
|
|
0x61, 0x00,
|
|
0x62, 0x00,
|
|
0x63, 0x00,
|
|
0x64, 0x00,
|
|
0x65, 0x00,
|
|
0x66, 0x00,
|
|
0x67, 0x00,
|
|
0x68, 0x00,
|
|
0x69, 0x00,
|
|
0x6a, 0x00,
|
|
0x6b, 0x00,
|
|
0x6c, 0x00,
|
|
0x6d, 0x00,
|
|
0x6e, 0x00,
|
|
0x6f, 0x00,
|
|
0x70, 0x00, /* video decoder reserved part */
|
|
0x71, 0x00,
|
|
0x72, 0x00,
|
|
0x73, 0x00,
|
|
0x74, 0x00,
|
|
0x75, 0x00,
|
|
0x76, 0x00,
|
|
0x77, 0x00,
|
|
0x78, 0x00,
|
|
0x79, 0x00,
|
|
0x7a, 0x00,
|
|
0x7b, 0x00,
|
|
0x7c, 0x00,
|
|
0x7d, 0x00,
|
|
0x7e, 0x00,
|
|
0x7f, 0x00,
|
|
0x80, 0x00, /* X-port, I-port and scaler */
|
|
0x81, 0x00,
|
|
0x82, 0x00,
|
|
0x83, 0x00,
|
|
0x84, 0xc5,
|
|
0x85, 0x0d, // hsync and vsync ?
|
|
0x86, 0x40,
|
|
0x87, 0x01,
|
|
0x88, 0x00,
|
|
0x89, 0x00,
|
|
0x8a, 0x00,
|
|
0x8b, 0x00,
|
|
0x8c, 0x00,
|
|
0x8d, 0x00,
|
|
0x8e, 0x00,
|
|
0x8f, 0x00,
|
|
0x90, 0x03, /* Task A definition */
|
|
0x91, 0x08,
|
|
0x92, 0x00,
|
|
0x93, 0x40,
|
|
0x94, 0x00, // window settings
|
|
0x95, 0x00,
|
|
0x96, 0x00,
|
|
0x97, 0x00,
|
|
0x98, 0x00,
|
|
0x99, 0x00,
|
|
0x9a, 0x00,
|
|
0x9b, 0x00,
|
|
0x9c, 0x00,
|
|
0x9d, 0x00,
|
|
0x9e, 0x00,
|
|
0x9f, 0x00,
|
|
0xa0, 0x01, /* horizontal integer prescaling ratio */
|
|
0xa1, 0x00, /* horizontal prescaler accumulation
|
|
* sequence length */
|
|
0xa2, 0x00, /* UV FIR filter, Y FIR filter, prescaler
|
|
* DC gain */
|
|
0xa3, 0x00,
|
|
0xa4, 0x80, // luminance brightness
|
|
0xa5, 0x40, // luminance gain
|
|
0xa6, 0x40, // chrominance saturation
|
|
0xa7, 0x00,
|
|
0xa8, 0x00, // horizontal luminance scaling increment
|
|
0xa9, 0x04,
|
|
0xaa, 0x00, // horizontal luminance phase offset
|
|
0xab, 0x00,
|
|
0xac, 0x00, // horizontal chrominance scaling increment
|
|
0xad, 0x02,
|
|
0xae, 0x00, // horizontal chrominance phase offset
|
|
0xaf, 0x00,
|
|
0xb0, 0x00, // vertical luminance scaling increment
|
|
0xb1, 0x04,
|
|
0xb2, 0x00, // vertical chrominance scaling increment
|
|
0xb3, 0x04,
|
|
0xb4, 0x00,
|
|
0xb5, 0x00,
|
|
0xb6, 0x00,
|
|
0xb7, 0x00,
|
|
0xb8, 0x00,
|
|
0xb9, 0x00,
|
|
0xba, 0x00,
|
|
0xbb, 0x00,
|
|
0xbc, 0x00,
|
|
0xbd, 0x00,
|
|
0xbe, 0x00,
|
|
0xbf, 0x00,
|
|
0xc0, 0x02, // Task B definition
|
|
0xc1, 0x08,
|
|
0xc2, 0x00,
|
|
0xc3, 0x40,
|
|
0xc4, 0x00, // window settings
|
|
0xc5, 0x00,
|
|
0xc6, 0x00,
|
|
0xc7, 0x00,
|
|
0xc8, 0x00,
|
|
0xc9, 0x00,
|
|
0xca, 0x00,
|
|
0xcb, 0x00,
|
|
0xcc, 0x00,
|
|
0xcd, 0x00,
|
|
0xce, 0x00,
|
|
0xcf, 0x00,
|
|
0xd0, 0x01, // horizontal integer prescaling ratio
|
|
0xd1, 0x00, // horizontal prescaler accumulation sequence length
|
|
0xd2, 0x00, // UV FIR filter, Y FIR filter, prescaler DC gain
|
|
0xd3, 0x00,
|
|
0xd4, 0x80, // luminance brightness
|
|
0xd5, 0x40, // luminance gain
|
|
0xd6, 0x40, // chrominance saturation
|
|
0xd7, 0x00,
|
|
0xd8, 0x00, // horizontal luminance scaling increment
|
|
0xd9, 0x04,
|
|
0xda, 0x00, // horizontal luminance phase offset
|
|
0xdb, 0x00,
|
|
0xdc, 0x00, // horizontal chrominance scaling increment
|
|
0xdd, 0x02,
|
|
0xde, 0x00, // horizontal chrominance phase offset
|
|
0xdf, 0x00,
|
|
0xe0, 0x00, // vertical luminance scaling increment
|
|
0xe1, 0x04,
|
|
0xe2, 0x00, // vertical chrominance scaling increment
|
|
0xe3, 0x04,
|
|
0xe4, 0x00,
|
|
0xe5, 0x00,
|
|
0xe6, 0x00,
|
|
0xe7, 0x00,
|
|
0xe8, 0x00,
|
|
0xe9, 0x00,
|
|
0xea, 0x00,
|
|
0xeb, 0x00,
|
|
0xec, 0x00,
|
|
0xed, 0x00,
|
|
0xee, 0x00,
|
|
0xef, 0x00
|
|
};
|
|
|
|
static int
|
|
saa7114_command (struct i2c_client *client,
|
|
unsigned int cmd,
|
|
void *arg)
|
|
{
|
|
struct saa7114 *decoder = i2c_get_clientdata(client);
|
|
|
|
switch (cmd) {
|
|
|
|
case 0:
|
|
//dprintk(1, KERN_INFO "%s: writing init\n", I2C_NAME(client));
|
|
//saa7114_write_block(client, init, sizeof(init));
|
|
break;
|
|
|
|
case DECODER_DUMP:
|
|
{
|
|
int i;
|
|
|
|
dprintk(1, KERN_INFO "%s: decoder dump\n", I2C_NAME(client));
|
|
|
|
for (i = 0; i < 32; i += 16) {
|
|
int j;
|
|
|
|
printk(KERN_DEBUG "%s: %03x", I2C_NAME(client), i);
|
|
for (j = 0; j < 16; ++j) {
|
|
printk(" %02x",
|
|
saa7114_read(client, i + j));
|
|
}
|
|
printk("\n");
|
|
}
|
|
}
|
|
break;
|
|
|
|
case DECODER_GET_CAPABILITIES:
|
|
{
|
|
struct video_decoder_capability *cap = arg;
|
|
|
|
dprintk(1, KERN_DEBUG "%s: decoder get capabilities\n",
|
|
I2C_NAME(client));
|
|
|
|
cap->flags = VIDEO_DECODER_PAL |
|
|
VIDEO_DECODER_NTSC |
|
|
VIDEO_DECODER_AUTO |
|
|
VIDEO_DECODER_CCIR;
|
|
cap->inputs = 8;
|
|
cap->outputs = 1;
|
|
}
|
|
break;
|
|
|
|
case DECODER_GET_STATUS:
|
|
{
|
|
int *iarg = arg;
|
|
int status;
|
|
int res;
|
|
|
|
status = saa7114_read(client, 0x1f);
|
|
|
|
dprintk(1, KERN_DEBUG "%s status: 0x%02x\n", I2C_NAME(client),
|
|
status);
|
|
res = 0;
|
|
if ((status & (1 << 6)) == 0) {
|
|
res |= DECODER_STATUS_GOOD;
|
|
}
|
|
switch (decoder->norm) {
|
|
case VIDEO_MODE_NTSC:
|
|
res |= DECODER_STATUS_NTSC;
|
|
break;
|
|
case VIDEO_MODE_PAL:
|
|
res |= DECODER_STATUS_PAL;
|
|
break;
|
|
case VIDEO_MODE_SECAM:
|
|
res |= DECODER_STATUS_SECAM;
|
|
break;
|
|
default:
|
|
case VIDEO_MODE_AUTO:
|
|
if ((status & (1 << 5)) != 0) {
|
|
res |= DECODER_STATUS_NTSC;
|
|
} else {
|
|
res |= DECODER_STATUS_PAL;
|
|
}
|
|
break;
|
|
}
|
|
if ((status & (1 << 0)) != 0) {
|
|
res |= DECODER_STATUS_COLOR;
|
|
}
|
|
*iarg = res;
|
|
}
|
|
break;
|
|
|
|
case DECODER_SET_NORM:
|
|
{
|
|
int *iarg = arg;
|
|
|
|
short int hoff = 0, voff = 0, w = 0, h = 0;
|
|
|
|
dprintk(1, KERN_DEBUG "%s: decoder set norm ",
|
|
I2C_NAME(client));
|
|
switch (*iarg) {
|
|
|
|
case VIDEO_MODE_NTSC:
|
|
dprintk(1, "NTSC\n");
|
|
decoder->reg[REG_ADDR(0x06)] =
|
|
SAA_7114_NTSC_HSYNC_START;
|
|
decoder->reg[REG_ADDR(0x07)] =
|
|
SAA_7114_NTSC_HSYNC_STOP;
|
|
|
|
decoder->reg[REG_ADDR(0x08)] = decoder->playback ? 0x7c : 0xb8; // PLL free when playback, PLL close when capture
|
|
|
|
decoder->reg[REG_ADDR(0x0e)] = 0x85;
|
|
decoder->reg[REG_ADDR(0x0f)] = 0x24;
|
|
|
|
hoff = SAA_7114_NTSC_HOFFSET;
|
|
voff = SAA_7114_NTSC_VOFFSET;
|
|
w = SAA_7114_NTSC_WIDTH;
|
|
h = SAA_7114_NTSC_HEIGHT;
|
|
|
|
break;
|
|
|
|
case VIDEO_MODE_PAL:
|
|
dprintk(1, "PAL\n");
|
|
decoder->reg[REG_ADDR(0x06)] =
|
|
SAA_7114_PAL_HSYNC_START;
|
|
decoder->reg[REG_ADDR(0x07)] =
|
|
SAA_7114_PAL_HSYNC_STOP;
|
|
|
|
decoder->reg[REG_ADDR(0x08)] = decoder->playback ? 0x7c : 0xb8; // PLL free when playback, PLL close when capture
|
|
|
|
decoder->reg[REG_ADDR(0x0e)] = 0x81;
|
|
decoder->reg[REG_ADDR(0x0f)] = 0x24;
|
|
|
|
hoff = SAA_7114_PAL_HOFFSET;
|
|
voff = SAA_7114_PAL_VOFFSET;
|
|
w = SAA_7114_PAL_WIDTH;
|
|
h = SAA_7114_PAL_HEIGHT;
|
|
|
|
break;
|
|
|
|
default:
|
|
dprintk(1, " Unknown video mode!!!\n");
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
decoder->reg[REG_ADDR(0x94)] = LOBYTE(hoff); // hoffset low
|
|
decoder->reg[REG_ADDR(0x95)] = HIBYTE(hoff) & 0x0f; // hoffset high
|
|
decoder->reg[REG_ADDR(0x96)] = LOBYTE(w); // width low
|
|
decoder->reg[REG_ADDR(0x97)] = HIBYTE(w) & 0x0f; // width high
|
|
decoder->reg[REG_ADDR(0x98)] = LOBYTE(voff); // voffset low
|
|
decoder->reg[REG_ADDR(0x99)] = HIBYTE(voff) & 0x0f; // voffset high
|
|
decoder->reg[REG_ADDR(0x9a)] = LOBYTE(h + 2); // height low
|
|
decoder->reg[REG_ADDR(0x9b)] = HIBYTE(h + 2) & 0x0f; // height high
|
|
decoder->reg[REG_ADDR(0x9c)] = LOBYTE(w); // out width low
|
|
decoder->reg[REG_ADDR(0x9d)] = HIBYTE(w) & 0x0f; // out width high
|
|
decoder->reg[REG_ADDR(0x9e)] = LOBYTE(h); // out height low
|
|
decoder->reg[REG_ADDR(0x9f)] = HIBYTE(h) & 0x0f; // out height high
|
|
|
|
decoder->reg[REG_ADDR(0xc4)] = LOBYTE(hoff); // hoffset low
|
|
decoder->reg[REG_ADDR(0xc5)] = HIBYTE(hoff) & 0x0f; // hoffset high
|
|
decoder->reg[REG_ADDR(0xc6)] = LOBYTE(w); // width low
|
|
decoder->reg[REG_ADDR(0xc7)] = HIBYTE(w) & 0x0f; // width high
|
|
decoder->reg[REG_ADDR(0xc8)] = LOBYTE(voff); // voffset low
|
|
decoder->reg[REG_ADDR(0xc9)] = HIBYTE(voff) & 0x0f; // voffset high
|
|
decoder->reg[REG_ADDR(0xca)] = LOBYTE(h + 2); // height low
|
|
decoder->reg[REG_ADDR(0xcb)] = HIBYTE(h + 2) & 0x0f; // height high
|
|
decoder->reg[REG_ADDR(0xcc)] = LOBYTE(w); // out width low
|
|
decoder->reg[REG_ADDR(0xcd)] = HIBYTE(w) & 0x0f; // out width high
|
|
decoder->reg[REG_ADDR(0xce)] = LOBYTE(h); // out height low
|
|
decoder->reg[REG_ADDR(0xcf)] = HIBYTE(h) & 0x0f; // out height high
|
|
|
|
|
|
saa7114_write(client, 0x80, 0x06); // i-port and scaler back end clock selection, task A&B off
|
|
saa7114_write(client, 0x88, 0xd8); // sw reset scaler
|
|
saa7114_write(client, 0x88, 0xf8); // sw reset scaler release
|
|
|
|
saa7114_write_block(client, decoder->reg + (0x06 << 1),
|
|
3 << 1);
|
|
saa7114_write_block(client, decoder->reg + (0x0e << 1),
|
|
2 << 1);
|
|
saa7114_write_block(client, decoder->reg + (0x5a << 1),
|
|
2 << 1);
|
|
|
|
saa7114_write_block(client, decoder->reg + (0x94 << 1),
|
|
(0x9f + 1 - 0x94) << 1);
|
|
saa7114_write_block(client, decoder->reg + (0xc4 << 1),
|
|
(0xcf + 1 - 0xc4) << 1);
|
|
|
|
saa7114_write(client, 0x88, 0xd8); // sw reset scaler
|
|
saa7114_write(client, 0x88, 0xf8); // sw reset scaler release
|
|
saa7114_write(client, 0x80, 0x36); // i-port and scaler back end clock selection
|
|
|
|
decoder->norm = *iarg;
|
|
}
|
|
break;
|
|
|
|
case DECODER_SET_INPUT:
|
|
{
|
|
int *iarg = arg;
|
|
|
|
dprintk(1, KERN_DEBUG "%s: decoder set input (%d)\n",
|
|
I2C_NAME(client), *iarg);
|
|
if (*iarg < 0 || *iarg > 7) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (decoder->input != *iarg) {
|
|
dprintk(1, KERN_DEBUG "%s: now setting %s input\n",
|
|
I2C_NAME(client),
|
|
*iarg >= 6 ? "S-Video" : "Composite");
|
|
decoder->input = *iarg;
|
|
|
|
/* select mode */
|
|
decoder->reg[REG_ADDR(0x02)] =
|
|
(decoder->
|
|
reg[REG_ADDR(0x02)] & 0xf0) | (decoder->
|
|
input <
|
|
6 ? 0x0 : 0x9);
|
|
saa7114_write(client, 0x02,
|
|
decoder->reg[REG_ADDR(0x02)]);
|
|
|
|
/* bypass chrominance trap for modes 6..9 */
|
|
decoder->reg[REG_ADDR(0x09)] =
|
|
(decoder->
|
|
reg[REG_ADDR(0x09)] & 0x7f) | (decoder->
|
|
input <
|
|
6 ? 0x0 :
|
|
0x80);
|
|
saa7114_write(client, 0x09,
|
|
decoder->reg[REG_ADDR(0x09)]);
|
|
|
|
decoder->reg[REG_ADDR(0x0e)] =
|
|
decoder->input <
|
|
6 ? decoder->
|
|
reg[REG_ADDR(0x0e)] | 1 : decoder->
|
|
reg[REG_ADDR(0x0e)] & ~1;
|
|
saa7114_write(client, 0x0e,
|
|
decoder->reg[REG_ADDR(0x0e)]);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case DECODER_SET_OUTPUT:
|
|
{
|
|
int *iarg = arg;
|
|
|
|
dprintk(1, KERN_DEBUG "%s: decoder set output\n",
|
|
I2C_NAME(client));
|
|
|
|
/* not much choice of outputs */
|
|
if (*iarg != 0) {
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case DECODER_ENABLE_OUTPUT:
|
|
{
|
|
int *iarg = arg;
|
|
int enable = (*iarg != 0);
|
|
|
|
dprintk(1, KERN_DEBUG "%s: decoder %s output\n",
|
|
I2C_NAME(client), enable ? "enable" : "disable");
|
|
|
|
decoder->playback = !enable;
|
|
|
|
if (decoder->enable != enable) {
|
|
decoder->enable = enable;
|
|
|
|
/* RJ: If output should be disabled (for
|
|
* playing videos), we also need a open PLL.
|
|
* The input is set to 0 (where no input
|
|
* source is connected), although this
|
|
* is not necessary.
|
|
*
|
|
* If output should be enabled, we have to
|
|
* reverse the above.
|
|
*/
|
|
|
|
if (decoder->enable) {
|
|
decoder->reg[REG_ADDR(0x08)] = 0xb8;
|
|
decoder->reg[REG_ADDR(0x12)] = 0xc9;
|
|
decoder->reg[REG_ADDR(0x13)] = 0x80;
|
|
decoder->reg[REG_ADDR(0x87)] = 0x01;
|
|
} else {
|
|
decoder->reg[REG_ADDR(0x08)] = 0x7c;
|
|
decoder->reg[REG_ADDR(0x12)] = 0x00;
|
|
decoder->reg[REG_ADDR(0x13)] = 0x00;
|
|
decoder->reg[REG_ADDR(0x87)] = 0x00;
|
|
}
|
|
|
|
saa7114_write_block(client,
|
|
decoder->reg + (0x12 << 1),
|
|
2 << 1);
|
|
saa7114_write(client, 0x08,
|
|
decoder->reg[REG_ADDR(0x08)]);
|
|
saa7114_write(client, 0x87,
|
|
decoder->reg[REG_ADDR(0x87)]);
|
|
saa7114_write(client, 0x88, 0xd8); // sw reset scaler
|
|
saa7114_write(client, 0x88, 0xf8); // sw reset scaler release
|
|
saa7114_write(client, 0x80, 0x36);
|
|
|
|
}
|
|
}
|
|
break;
|
|
|
|
case DECODER_SET_PICTURE:
|
|
{
|
|
struct video_picture *pic = arg;
|
|
|
|
dprintk(1,
|
|
KERN_DEBUG
|
|
"%s: decoder set picture bright=%d contrast=%d saturation=%d hue=%d\n",
|
|
I2C_NAME(client), pic->brightness, pic->contrast,
|
|
pic->colour, pic->hue);
|
|
|
|
if (decoder->bright != pic->brightness) {
|
|
/* We want 0 to 255 we get 0-65535 */
|
|
decoder->bright = pic->brightness;
|
|
saa7114_write(client, 0x0a, decoder->bright >> 8);
|
|
}
|
|
if (decoder->contrast != pic->contrast) {
|
|
/* We want 0 to 127 we get 0-65535 */
|
|
decoder->contrast = pic->contrast;
|
|
saa7114_write(client, 0x0b,
|
|
decoder->contrast >> 9);
|
|
}
|
|
if (decoder->sat != pic->colour) {
|
|
/* We want 0 to 127 we get 0-65535 */
|
|
decoder->sat = pic->colour;
|
|
saa7114_write(client, 0x0c, decoder->sat >> 9);
|
|
}
|
|
if (decoder->hue != pic->hue) {
|
|
/* We want -128 to 127 we get 0-65535 */
|
|
decoder->hue = pic->hue;
|
|
saa7114_write(client, 0x0d,
|
|
(decoder->hue - 32768) >> 8);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------- */
|
|
|
|
/*
|
|
* Generic i2c probe
|
|
* concerning the addresses: i2c wants 7 bit (without the r/w bit), so '>>1'
|
|
*/
|
|
static unsigned short normal_i2c[] =
|
|
{ I2C_SAA7114 >> 1, I2C_SAA7114A >> 1, I2C_CLIENT_END };
|
|
|
|
static unsigned short ignore = I2C_CLIENT_END;
|
|
|
|
static struct i2c_client_address_data addr_data = {
|
|
.normal_i2c = normal_i2c,
|
|
.probe = &ignore,
|
|
.ignore = &ignore,
|
|
};
|
|
|
|
static struct i2c_driver i2c_driver_saa7114;
|
|
|
|
static int
|
|
saa7114_detect_client (struct i2c_adapter *adapter,
|
|
int address,
|
|
int kind)
|
|
{
|
|
int i, err[30];
|
|
short int hoff = SAA_7114_NTSC_HOFFSET;
|
|
short int voff = SAA_7114_NTSC_VOFFSET;
|
|
short int w = SAA_7114_NTSC_WIDTH;
|
|
short int h = SAA_7114_NTSC_HEIGHT;
|
|
struct i2c_client *client;
|
|
struct saa7114 *decoder;
|
|
|
|
dprintk(1,
|
|
KERN_INFO
|
|
"saa7114.c: detecting saa7114 client on address 0x%x\n",
|
|
address << 1);
|
|
|
|
/* Check if the adapter supports the needed features */
|
|
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
|
|
return 0;
|
|
|
|
client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
|
|
if (client == 0)
|
|
return -ENOMEM;
|
|
client->addr = address;
|
|
client->adapter = adapter;
|
|
client->driver = &i2c_driver_saa7114;
|
|
strlcpy(I2C_NAME(client), "saa7114", sizeof(I2C_NAME(client)));
|
|
|
|
decoder = kzalloc(sizeof(struct saa7114), GFP_KERNEL);
|
|
if (decoder == NULL) {
|
|
kfree(client);
|
|
return -ENOMEM;
|
|
}
|
|
decoder->norm = VIDEO_MODE_NTSC;
|
|
decoder->input = -1;
|
|
decoder->enable = 1;
|
|
decoder->bright = 32768;
|
|
decoder->contrast = 32768;
|
|
decoder->hue = 32768;
|
|
decoder->sat = 32768;
|
|
decoder->playback = 0; // initially capture mode useda
|
|
i2c_set_clientdata(client, decoder);
|
|
|
|
memcpy(decoder->reg, init, sizeof(init));
|
|
|
|
decoder->reg[REG_ADDR(0x94)] = LOBYTE(hoff); // hoffset low
|
|
decoder->reg[REG_ADDR(0x95)] = HIBYTE(hoff) & 0x0f; // hoffset high
|
|
decoder->reg[REG_ADDR(0x96)] = LOBYTE(w); // width low
|
|
decoder->reg[REG_ADDR(0x97)] = HIBYTE(w) & 0x0f; // width high
|
|
decoder->reg[REG_ADDR(0x98)] = LOBYTE(voff); // voffset low
|
|
decoder->reg[REG_ADDR(0x99)] = HIBYTE(voff) & 0x0f; // voffset high
|
|
decoder->reg[REG_ADDR(0x9a)] = LOBYTE(h + 2); // height low
|
|
decoder->reg[REG_ADDR(0x9b)] = HIBYTE(h + 2) & 0x0f; // height high
|
|
decoder->reg[REG_ADDR(0x9c)] = LOBYTE(w); // out width low
|
|
decoder->reg[REG_ADDR(0x9d)] = HIBYTE(w) & 0x0f; // out width high
|
|
decoder->reg[REG_ADDR(0x9e)] = LOBYTE(h); // out height low
|
|
decoder->reg[REG_ADDR(0x9f)] = HIBYTE(h) & 0x0f; // out height high
|
|
|
|
decoder->reg[REG_ADDR(0xc4)] = LOBYTE(hoff); // hoffset low
|
|
decoder->reg[REG_ADDR(0xc5)] = HIBYTE(hoff) & 0x0f; // hoffset high
|
|
decoder->reg[REG_ADDR(0xc6)] = LOBYTE(w); // width low
|
|
decoder->reg[REG_ADDR(0xc7)] = HIBYTE(w) & 0x0f; // width high
|
|
decoder->reg[REG_ADDR(0xc8)] = LOBYTE(voff); // voffset low
|
|
decoder->reg[REG_ADDR(0xc9)] = HIBYTE(voff) & 0x0f; // voffset high
|
|
decoder->reg[REG_ADDR(0xca)] = LOBYTE(h + 2); // height low
|
|
decoder->reg[REG_ADDR(0xcb)] = HIBYTE(h + 2) & 0x0f; // height high
|
|
decoder->reg[REG_ADDR(0xcc)] = LOBYTE(w); // out width low
|
|
decoder->reg[REG_ADDR(0xcd)] = HIBYTE(w) & 0x0f; // out width high
|
|
decoder->reg[REG_ADDR(0xce)] = LOBYTE(h); // out height low
|
|
decoder->reg[REG_ADDR(0xcf)] = HIBYTE(h) & 0x0f; // out height high
|
|
|
|
decoder->reg[REG_ADDR(0xb8)] =
|
|
LOBYTE(LOWORD(SAA_7114_VERTICAL_CHROMA_OFFSET));
|
|
decoder->reg[REG_ADDR(0xb9)] =
|
|
HIBYTE(LOWORD(SAA_7114_VERTICAL_CHROMA_OFFSET));
|
|
decoder->reg[REG_ADDR(0xba)] =
|
|
LOBYTE(HIWORD(SAA_7114_VERTICAL_CHROMA_OFFSET));
|
|
decoder->reg[REG_ADDR(0xbb)] =
|
|
HIBYTE(HIWORD(SAA_7114_VERTICAL_CHROMA_OFFSET));
|
|
|
|
decoder->reg[REG_ADDR(0xbc)] =
|
|
LOBYTE(LOWORD(SAA_7114_VERTICAL_LUMA_OFFSET));
|
|
decoder->reg[REG_ADDR(0xbd)] =
|
|
HIBYTE(LOWORD(SAA_7114_VERTICAL_LUMA_OFFSET));
|
|
decoder->reg[REG_ADDR(0xbe)] =
|
|
LOBYTE(HIWORD(SAA_7114_VERTICAL_LUMA_OFFSET));
|
|
decoder->reg[REG_ADDR(0xbf)] =
|
|
HIBYTE(HIWORD(SAA_7114_VERTICAL_LUMA_OFFSET));
|
|
|
|
decoder->reg[REG_ADDR(0xe8)] =
|
|
LOBYTE(LOWORD(SAA_7114_VERTICAL_CHROMA_OFFSET));
|
|
decoder->reg[REG_ADDR(0xe9)] =
|
|
HIBYTE(LOWORD(SAA_7114_VERTICAL_CHROMA_OFFSET));
|
|
decoder->reg[REG_ADDR(0xea)] =
|
|
LOBYTE(HIWORD(SAA_7114_VERTICAL_CHROMA_OFFSET));
|
|
decoder->reg[REG_ADDR(0xeb)] =
|
|
HIBYTE(HIWORD(SAA_7114_VERTICAL_CHROMA_OFFSET));
|
|
|
|
decoder->reg[REG_ADDR(0xec)] =
|
|
LOBYTE(LOWORD(SAA_7114_VERTICAL_LUMA_OFFSET));
|
|
decoder->reg[REG_ADDR(0xed)] =
|
|
HIBYTE(LOWORD(SAA_7114_VERTICAL_LUMA_OFFSET));
|
|
decoder->reg[REG_ADDR(0xee)] =
|
|
LOBYTE(HIWORD(SAA_7114_VERTICAL_LUMA_OFFSET));
|
|
decoder->reg[REG_ADDR(0xef)] =
|
|
HIBYTE(HIWORD(SAA_7114_VERTICAL_LUMA_OFFSET));
|
|
|
|
|
|
decoder->reg[REG_ADDR(0x13)] = 0x80; // RTC0 on
|
|
decoder->reg[REG_ADDR(0x87)] = 0x01; // I-Port
|
|
decoder->reg[REG_ADDR(0x12)] = 0xc9; // RTS0
|
|
|
|
decoder->reg[REG_ADDR(0x02)] = 0xc0; // set composite1 input, aveasy
|
|
decoder->reg[REG_ADDR(0x09)] = 0x00; // chrominance trap
|
|
decoder->reg[REG_ADDR(0x0e)] |= 1; // combfilter on
|
|
|
|
|
|
dprintk(1, KERN_DEBUG "%s_attach: starting decoder init\n",
|
|
I2C_NAME(client));
|
|
|
|
err[0] =
|
|
saa7114_write_block(client, decoder->reg + (0x20 << 1),
|
|
0x10 << 1);
|
|
err[1] =
|
|
saa7114_write_block(client, decoder->reg + (0x30 << 1),
|
|
0x10 << 1);
|
|
err[2] =
|
|
saa7114_write_block(client, decoder->reg + (0x63 << 1),
|
|
(0x7f + 1 - 0x63) << 1);
|
|
err[3] =
|
|
saa7114_write_block(client, decoder->reg + (0x89 << 1),
|
|
6 << 1);
|
|
err[4] =
|
|
saa7114_write_block(client, decoder->reg + (0xb8 << 1),
|
|
8 << 1);
|
|
err[5] =
|
|
saa7114_write_block(client, decoder->reg + (0xe8 << 1),
|
|
8 << 1);
|
|
|
|
|
|
for (i = 0; i <= 5; i++) {
|
|
if (err[i] < 0) {
|
|
dprintk(1,
|
|
KERN_ERR
|
|
"%s_attach: init error %d at stage %d, leaving attach.\n",
|
|
I2C_NAME(client), i, err[i]);
|
|
kfree(decoder);
|
|
kfree(client);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
for (i = 6; i < 8; i++) {
|
|
dprintk(1,
|
|
KERN_DEBUG
|
|
"%s_attach: reg[0x%02x] = 0x%02x (0x%02x)\n",
|
|
I2C_NAME(client), i, saa7114_read(client, i),
|
|
decoder->reg[REG_ADDR(i)]);
|
|
}
|
|
|
|
dprintk(1,
|
|
KERN_DEBUG
|
|
"%s_attach: performing decoder reset sequence\n",
|
|
I2C_NAME(client));
|
|
|
|
err[6] = saa7114_write(client, 0x80, 0x06); // i-port and scaler backend clock selection, task A&B off
|
|
err[7] = saa7114_write(client, 0x88, 0xd8); // sw reset scaler
|
|
err[8] = saa7114_write(client, 0x88, 0xf8); // sw reset scaler release
|
|
|
|
for (i = 6; i <= 8; i++) {
|
|
if (err[i] < 0) {
|
|
dprintk(1,
|
|
KERN_ERR
|
|
"%s_attach: init error %d at stage %d, leaving attach.\n",
|
|
I2C_NAME(client), i, err[i]);
|
|
kfree(decoder);
|
|
kfree(client);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
dprintk(1, KERN_INFO "%s_attach: performing the rest of init\n",
|
|
I2C_NAME(client));
|
|
|
|
|
|
err[9] = saa7114_write(client, 0x01, decoder->reg[REG_ADDR(0x01)]);
|
|
err[10] = saa7114_write_block(client, decoder->reg + (0x03 << 1), (0x1e + 1 - 0x03) << 1); // big seq
|
|
err[11] = saa7114_write_block(client, decoder->reg + (0x40 << 1), (0x5f + 1 - 0x40) << 1); // slicer
|
|
err[12] = saa7114_write_block(client, decoder->reg + (0x81 << 1), 2 << 1); // ?
|
|
err[13] = saa7114_write_block(client, decoder->reg + (0x83 << 1), 5 << 1); // ?
|
|
err[14] = saa7114_write_block(client, decoder->reg + (0x90 << 1), 4 << 1); // Task A
|
|
err[15] =
|
|
saa7114_write_block(client, decoder->reg + (0x94 << 1),
|
|
12 << 1);
|
|
err[16] =
|
|
saa7114_write_block(client, decoder->reg + (0xa0 << 1),
|
|
8 << 1);
|
|
err[17] =
|
|
saa7114_write_block(client, decoder->reg + (0xa8 << 1),
|
|
8 << 1);
|
|
err[18] =
|
|
saa7114_write_block(client, decoder->reg + (0xb0 << 1),
|
|
8 << 1);
|
|
err[19] = saa7114_write_block(client, decoder->reg + (0xc0 << 1), 4 << 1); // Task B
|
|
err[15] =
|
|
saa7114_write_block(client, decoder->reg + (0xc4 << 1),
|
|
12 << 1);
|
|
err[16] =
|
|
saa7114_write_block(client, decoder->reg + (0xd0 << 1),
|
|
8 << 1);
|
|
err[17] =
|
|
saa7114_write_block(client, decoder->reg + (0xd8 << 1),
|
|
8 << 1);
|
|
err[18] =
|
|
saa7114_write_block(client, decoder->reg + (0xe0 << 1),
|
|
8 << 1);
|
|
|
|
for (i = 9; i <= 18; i++) {
|
|
if (err[i] < 0) {
|
|
dprintk(1,
|
|
KERN_ERR
|
|
"%s_attach: init error %d at stage %d, leaving attach.\n",
|
|
I2C_NAME(client), i, err[i]);
|
|
kfree(decoder);
|
|
kfree(client);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
for (i = 6; i < 8; i++) {
|
|
dprintk(1,
|
|
KERN_DEBUG
|
|
"%s_attach: reg[0x%02x] = 0x%02x (0x%02x)\n",
|
|
I2C_NAME(client), i, saa7114_read(client, i),
|
|
decoder->reg[REG_ADDR(i)]);
|
|
}
|
|
|
|
|
|
for (i = 0x11; i <= 0x13; i++) {
|
|
dprintk(1,
|
|
KERN_DEBUG
|
|
"%s_attach: reg[0x%02x] = 0x%02x (0x%02x)\n",
|
|
I2C_NAME(client), i, saa7114_read(client, i),
|
|
decoder->reg[REG_ADDR(i)]);
|
|
}
|
|
|
|
|
|
dprintk(1, KERN_DEBUG "%s_attach: setting video input\n",
|
|
I2C_NAME(client));
|
|
|
|
err[19] =
|
|
saa7114_write(client, 0x02, decoder->reg[REG_ADDR(0x02)]);
|
|
err[20] =
|
|
saa7114_write(client, 0x09, decoder->reg[REG_ADDR(0x09)]);
|
|
err[21] =
|
|
saa7114_write(client, 0x0e, decoder->reg[REG_ADDR(0x0e)]);
|
|
|
|
for (i = 19; i <= 21; i++) {
|
|
if (err[i] < 0) {
|
|
dprintk(1,
|
|
KERN_ERR
|
|
"%s_attach: init error %d at stage %d, leaving attach.\n",
|
|
I2C_NAME(client), i, err[i]);
|
|
kfree(decoder);
|
|
kfree(client);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
dprintk(1,
|
|
KERN_DEBUG
|
|
"%s_attach: performing decoder reset sequence\n",
|
|
I2C_NAME(client));
|
|
|
|
err[22] = saa7114_write(client, 0x88, 0xd8); // sw reset scaler
|
|
err[23] = saa7114_write(client, 0x88, 0xf8); // sw reset scaler release
|
|
err[24] = saa7114_write(client, 0x80, 0x36); // i-port and scaler backend clock selection, task A&B off
|
|
|
|
|
|
for (i = 22; i <= 24; i++) {
|
|
if (err[i] < 0) {
|
|
dprintk(1,
|
|
KERN_ERR
|
|
"%s_attach: init error %d at stage %d, leaving attach.\n",
|
|
I2C_NAME(client), i, err[i]);
|
|
kfree(decoder);
|
|
kfree(client);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
err[25] = saa7114_write(client, 0x06, init[REG_ADDR(0x06)]);
|
|
err[26] = saa7114_write(client, 0x07, init[REG_ADDR(0x07)]);
|
|
err[27] = saa7114_write(client, 0x10, init[REG_ADDR(0x10)]);
|
|
|
|
dprintk(1,
|
|
KERN_INFO
|
|
"%s_attach: chip version %x, decoder status 0x%02x\n",
|
|
I2C_NAME(client), saa7114_read(client, 0x00) >> 4,
|
|
saa7114_read(client, 0x1f));
|
|
dprintk(1,
|
|
KERN_DEBUG
|
|
"%s_attach: power save control: 0x%02x, scaler status: 0x%02x\n",
|
|
I2C_NAME(client), saa7114_read(client, 0x88),
|
|
saa7114_read(client, 0x8f));
|
|
|
|
|
|
for (i = 0x94; i < 0x96; i++) {
|
|
dprintk(1,
|
|
KERN_DEBUG
|
|
"%s_attach: reg[0x%02x] = 0x%02x (0x%02x)\n",
|
|
I2C_NAME(client), i, saa7114_read(client, i),
|
|
decoder->reg[REG_ADDR(i)]);
|
|
}
|
|
|
|
i = i2c_attach_client(client);
|
|
if (i) {
|
|
kfree(client);
|
|
kfree(decoder);
|
|
return i;
|
|
}
|
|
|
|
//i = saa7114_write_block(client, init, sizeof(init));
|
|
i = 0;
|
|
if (i < 0) {
|
|
dprintk(1, KERN_ERR "%s_attach error: init status %d\n",
|
|
I2C_NAME(client), i);
|
|
} else {
|
|
dprintk(1,
|
|
KERN_INFO
|
|
"%s_attach: chip version %x at address 0x%x\n",
|
|
I2C_NAME(client), saa7114_read(client, 0x00) >> 4,
|
|
client->addr << 1);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
saa7114_attach_adapter (struct i2c_adapter *adapter)
|
|
{
|
|
dprintk(1,
|
|
KERN_INFO
|
|
"saa7114.c: starting probe for adapter %s (0x%x)\n",
|
|
I2C_NAME(adapter), adapter->id);
|
|
return i2c_probe(adapter, &addr_data, &saa7114_detect_client);
|
|
}
|
|
|
|
static int
|
|
saa7114_detach_client (struct i2c_client *client)
|
|
{
|
|
struct saa7114 *decoder = i2c_get_clientdata(client);
|
|
int err;
|
|
|
|
err = i2c_detach_client(client);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
|
|
kfree(decoder);
|
|
kfree(client);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------- */
|
|
|
|
static struct i2c_driver i2c_driver_saa7114 = {
|
|
.driver = {
|
|
.name = "saa7114",
|
|
},
|
|
|
|
.id = I2C_DRIVERID_SAA7114,
|
|
|
|
.attach_adapter = saa7114_attach_adapter,
|
|
.detach_client = saa7114_detach_client,
|
|
.command = saa7114_command,
|
|
};
|
|
|
|
static int __init
|
|
saa7114_init (void)
|
|
{
|
|
return i2c_add_driver(&i2c_driver_saa7114);
|
|
}
|
|
|
|
static void __exit
|
|
saa7114_exit (void)
|
|
{
|
|
i2c_del_driver(&i2c_driver_saa7114);
|
|
}
|
|
|
|
module_init(saa7114_init);
|
|
module_exit(saa7114_exit);
|