URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [media/] [video/] [saa7111.c] - Blame information for rev 78

Go to most recent revision | Details | Compare with Previous | View Log


/*
 * saa7111 - Philips SAA7111A video decoder driver version 0.0.3
 *
 * 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)
 *
 * Changes by Michael Hunold <michael@mihu.de>
 *    - implemented DECODER_SET_GPIO, DECODER_INIT, DECODER_SET_VBI_BYPASS
 *
 * 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 SAA7111 video decoder driver");
MODULE_AUTHOR("Dave Perks");
MODULE_LICENSE("GPL");
 
 
#define I2C_NAME(s) (s)->name
 
 
static int debug = 0;
module_param(debug, int, 0644);
MODULE_PARM_DESC(debug, "Debug level (0-1)");
 
#define dprintk(num, format, args...) \
        do { \
                if (debug >= num) \
                        printk(format, ##args); \
        } while (0)
 
/* ----------------------------------------------------------------------- */
 
#define SAA7111_NR_REG          0x18
 
struct saa7111 {
        unsigned char reg[SAA7111_NR_REG];
 
        int norm;
        int input;
        int enable;
};
 
#define   I2C_SAA7111        0x48
 
/* ----------------------------------------------------------------------- */
 
static inline int
saa7111_write (struct i2c_client *client,
               u8                 reg,
               u8                 value)
{
        struct saa7111 *decoder = i2c_get_clientdata(client);
 
        decoder->reg[reg] = value;
        return i2c_smbus_write_byte_data(client, reg, value);
}
 
static inline void
saa7111_write_if_changed(struct i2c_client *client, u8 reg, u8 value)
{
        struct saa7111 *decoder = i2c_get_clientdata(client);
 
        if (decoder->reg[reg] != value) {
                decoder->reg[reg] = value;
                i2c_smbus_write_byte_data(client, reg, value);
        }
}
 
static int
saa7111_write_block (struct i2c_client *client,
                     const u8          *data,
                     unsigned int       len)
{
        int ret = -1;
        u8 reg;
 
        /* the saa7111 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 */
                struct saa7111 *decoder = i2c_get_clientdata(client);
                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++] =
                                    decoder->reg[reg++] = data[1];
                                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 = saa7111_write(client, reg,
                                                 *data++)) < 0)
                                break;
                        len -= 2;
                }
        }
 
        return ret;
}
 
static int
saa7111_init_decoder (struct i2c_client *client,
              struct video_decoder_init *init)
{
        return saa7111_write_block(client, init->data, init->len);
}
 
static inline int
saa7111_read (struct i2c_client *client,
              u8                 reg)
{
        return i2c_smbus_read_byte_data(client, reg);
}
 
/* ----------------------------------------------------------------------- */
 
static const unsigned char saa7111_i2c_init[] = {
        0x00, 0x00,             /* 00 - ID byte */
        0x01, 0x00,             /* 01 - reserved */
 
        /*front end */
        0x02, 0xd0,             /* 02 - FUSE=3, GUDL=2, MODE=0 */
        0x03, 0x23,             /* 03 - HLNRS=0, VBSL=1, WPOFF=0,
                                 * HOLDG=0, GAFIX=0, GAI1=256, GAI2=256 */
        0x04, 0x00,             /* 04 - GAI1=256 */
        0x05, 0x00,             /* 05 - GAI2=256 */
 
        /* decoder */
        0x06, 0xf3,             /* 06 - HSB at  13(50Hz) /  17(60Hz)
                                 * pixels after end of last line */
        /*0x07, 0x13,     * 07 - HSS at 113(50Hz) / 117(60Hz) pixels
                                 * after end of last line */
        0x07, 0xe8,             /* 07 - HSS seems to be needed to
                                 * work with NTSC, too */
        0x08, 0xc8,             /* 08 - AUFD=1, FSEL=1, EXFIL=0,
                                 * VTRC=1, HPLL=0, VNOI=0 */
        0x09, 0x01,             /* 09 - BYPS=0, PREF=0, BPSS=0,
                                 * VBLB=0, UPTCV=0, APER=1 */
        0x0a, 0x80,             /* 0a - BRIG=128 */
        0x0b, 0x47,             /* 0b - CONT=1.109 */
        0x0c, 0x40,             /* 0c - SATN=1.0 */
        0x0d, 0x00,             /* 0d - HUE=0 */
        0x0e, 0x01,             /* 0e - CDTO=0, CSTD=0, DCCF=0,
                                 * FCTC=0, CHBW=1 */
        0x0f, 0x00,             /* 0f - reserved */
        0x10, 0x48,             /* 10 - OFTS=1, HDEL=0, VRLN=1, YDEL=0 */
        0x11, 0x1c,             /* 11 - GPSW=0, CM99=0, FECO=0, COMPO=1,
                                 * OEYC=1, OEHV=1, VIPB=0, COLO=0 */
        0x12, 0x00,             /* 12 - output control 2 */
        0x13, 0x00,             /* 13 - output control 3 */
        0x14, 0x00,             /* 14 - reserved */
        0x15, 0x00,             /* 15 - VBI */
        0x16, 0x00,             /* 16 - VBI */
        0x17, 0x00,             /* 17 - VBI */
};
 
static int
saa7111_command (struct i2c_client *client,
                 unsigned int       cmd,
                 void              *arg)
{
        struct saa7111 *decoder = i2c_get_clientdata(client);
 
        switch (cmd) {
 
        case 0:
                break;
        case DECODER_INIT:
        {
                struct video_decoder_init *init = arg;
                if (NULL != init)
                        return saa7111_init_decoder(client, init);
                else {
                        struct video_decoder_init vdi;
                        vdi.data = saa7111_i2c_init;
                        vdi.len = sizeof(saa7111_i2c_init);
                        return saa7111_init_decoder(client, &vdi);
                }
        }
 
        case DECODER_DUMP:
        {
                int i;
 
                for (i = 0; i < SAA7111_NR_REG; i += 16) {
                        int j;
 
                        printk(KERN_DEBUG "%s: %03x", I2C_NAME(client), i);
                        for (j = 0; j < 16 && i + j < SAA7111_NR_REG; ++j) {
                                printk(" %02x",
                                       saa7111_read(client, i + j));
                        }
                        printk("\n");
                }
        }
                break;
 
        case DECODER_GET_CAPABILITIES:
        {
                struct video_decoder_capability *cap = arg;
 
                cap->flags = VIDEO_DECODER_PAL |
                             VIDEO_DECODER_NTSC |
                             VIDEO_DECODER_SECAM |
                             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 = saa7111_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_GPIO:
        {
                int *iarg = arg;
                if (0 != *iarg) {
                        saa7111_write(client, 0x11,
                                (decoder->reg[0x11] | 0x80));
                } else {
                        saa7111_write(client, 0x11,
                                (decoder->reg[0x11] & 0x7f));
                }
                break;
        }
 
        case DECODER_SET_VBI_BYPASS:
        {
                int *iarg = arg;
                if (0 != *iarg) {
                        saa7111_write(client, 0x13,
                                (decoder->reg[0x13] & 0xf0) | 0x0a);
                } else {
                        saa7111_write(client, 0x13,
                                (decoder->reg[0x13] & 0xf0));
                }
                break;
        }
 
        case DECODER_SET_NORM:
        {
                int *iarg = arg;
 
                switch (*iarg) {
 
                case VIDEO_MODE_NTSC:
                        saa7111_write(client, 0x08,
                                      (decoder->reg[0x08] & 0x3f) | 0x40);
                        saa7111_write(client, 0x0e,
                                      (decoder->reg[0x0e] & 0x8f));
                        break;
 
                case VIDEO_MODE_PAL:
                        saa7111_write(client, 0x08,
                                      (decoder->reg[0x08] & 0x3f) | 0x00);
                        saa7111_write(client, 0x0e,
                                      (decoder->reg[0x0e] & 0x8f));
                        break;
 
                case VIDEO_MODE_SECAM:
                        saa7111_write(client, 0x08,
                                      (decoder->reg[0x08] & 0x3f) | 0x00);
                        saa7111_write(client, 0x0e,
                                      (decoder->reg[0x0e] & 0x8f) | 0x50);
                        break;
 
                case VIDEO_MODE_AUTO:
                        saa7111_write(client, 0x08,
                                      (decoder->reg[0x08] & 0x3f) | 0x80);
                        saa7111_write(client, 0x0e,
                                      (decoder->reg[0x0e] & 0x8f));
                        break;
 
                default:
                        return -EINVAL;
 
                }
                decoder->norm = *iarg;
        }
                break;
 
        case DECODER_SET_INPUT:
        {
                int *iarg = arg;
 
                if (*iarg < 0 || *iarg > 7) {
                        return -EINVAL;
                }
 
                if (decoder->input != *iarg) {
                        decoder->input = *iarg;
                        /* select mode */
                        saa7111_write(client, 0x02,
                                      (decoder->
                                       reg[0x02] & 0xf8) | decoder->input);
                        /* bypass chrominance trap for modes 4..7 */
                        saa7111_write(client, 0x09,
                                      (decoder->
                                       reg[0x09] & 0x7f) | ((decoder->
                                                             input >
                                                             3) ? 0x80 :
                                                            0));
                }
        }
                break;
 
        case DECODER_SET_OUTPUT:
        {
                int *iarg = arg;
 
                /* not much choice of outputs */
                if (*iarg != 0) {
                        return -EINVAL;
                }
        }
                break;
 
        case DECODER_ENABLE_OUTPUT:
        {
                int *iarg = arg;
                int enable = (*iarg != 0);
 
                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) {
                                saa7111_write(client, 0x02,
                                              (decoder->
                                               reg[0x02] & 0xf8) |
                                              decoder->input);
                                saa7111_write(client, 0x08,
                                              (decoder->reg[0x08] & 0xfb));
                                saa7111_write(client, 0x11,
                                              (decoder->
                                               reg[0x11] & 0xf3) | 0x0c);
                        } else {
                                saa7111_write(client, 0x02,
                                              (decoder->reg[0x02] & 0xf8));
                                saa7111_write(client, 0x08,
                                              (decoder->
                                               reg[0x08] & 0xfb) | 0x04);
                                saa7111_write(client, 0x11,
                                              (decoder->reg[0x11] & 0xf3));
                        }
                }
        }
                break;
 
        case DECODER_SET_PICTURE:
        {
                struct video_picture *pic = arg;
 
                /* We want 0 to 255 we get 0-65535 */
                saa7111_write_if_changed(client, 0x0a, pic->brightness >> 8);
                /* We want 0 to 127 we get 0-65535 */
                saa7111_write(client, 0x0b, pic->contrast >> 9);
                /* We want 0 to 127 we get 0-65535 */
                saa7111_write(client, 0x0c, pic->colour >> 9);
                /* We want -128 to 127 we get 0-65535 */
                saa7111_write(client, 0x0d, (pic->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_SAA7111 >> 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_saa7111;
 
static int
saa7111_detect_client (struct i2c_adapter *adapter,
                       int                 address,
                       int                 kind)
{
        int i;
        struct i2c_client *client;
        struct saa7111 *decoder;
        struct video_decoder_init vdi;
 
        dprintk(1,
                KERN_INFO
                "saa7111.c: detecting saa7111 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_saa7111;
        strlcpy(I2C_NAME(client), "saa7111", sizeof(I2C_NAME(client)));
 
        decoder = kzalloc(sizeof(struct saa7111), GFP_KERNEL);
        if (decoder == NULL) {
                kfree(client);
                return -ENOMEM;
        }
        decoder->norm = VIDEO_MODE_NTSC;
        decoder->input = 0;
        decoder->enable = 1;
        i2c_set_clientdata(client, decoder);
 
        i = i2c_attach_client(client);
        if (i) {
                kfree(client);
                kfree(decoder);
                return i;
        }
 
        vdi.data = saa7111_i2c_init;
        vdi.len = sizeof(saa7111_i2c_init);
        i = saa7111_init_decoder(client, &vdi);
        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), saa7111_read(client, 0x00) >> 4,
                        client->addr << 1);
        }
 
        return 0;
}
 
static int
saa7111_attach_adapter (struct i2c_adapter *adapter)
{
        dprintk(1,
                KERN_INFO
                "saa7111.c: starting probe for adapter %s (0x%x)\n",
                I2C_NAME(adapter), adapter->id);
        return i2c_probe(adapter, &addr_data, &saa7111_detect_client);
}
 
static int
saa7111_detach_client (struct i2c_client *client)
{
        struct saa7111 *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_saa7111 = {
        .driver = {
                .name = "saa7111",
        },
 
        .id = I2C_DRIVERID_SAA7111A,
 
        .attach_adapter = saa7111_attach_adapter,
        .detach_client = saa7111_detach_client,
        .command = saa7111_command,
};
 
static int __init
saa7111_init (void)
{
        return i2c_add_driver(&i2c_driver_saa7111);
}
 
static void __exit
saa7111_exit (void)
{
        i2c_del_driver(&i2c_driver_saa7111);
}
 
module_init(saa7111_init);
module_exit(saa7111_exit);

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [media/] [video/] [saa7111.c] - Blame information for rev 78

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`* saa7111 - Philips SAA7111A video decoder driver version 0.0.3`
3			`*`
4			`* Copyright (C) 1998 Dave Perks <dperks@ibm.net>`
5			`*`
6			`* Slight changes for video timing and attachment output by`
7			`* Wolfgang Scherr <scherr@net4you.net>`
8			`*`
9			`* Changes by Ronald Bultje <rbultje@ronald.bitfreak.net>`
10			`* - moved over to linux>=2.4.x i2c protocol (1/1/2003)`
11			`*`
12			`* Changes by Michael Hunold <michael@mihu.de>`
13			`* - implemented DECODER_SET_GPIO, DECODER_INIT, DECODER_SET_VBI_BYPASS`
14			`*`
15			`* This program is free software; you can redistribute it and/or modify`
16			`* it under the terms of the GNU General Public License as published by`
17			`* the Free Software Foundation; either version 2 of the License, or`
18			`* (at your option) any later version.`
19			`*`
20			`* This program is distributed in the hope that it will be useful,`
21			`* but WITHOUT ANY WARRANTY; without even the implied warranty of`
22			`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
23			`* GNU General Public License for more details.`
24			`*`
25			`* You should have received a copy of the GNU General Public License`
26			`* along with this program; if not, write to the Free Software`
27			`* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.`
28			`*/`
29
30			`#include <linux/module.h>`
31			`#include <linux/init.h>`
32			`#include <linux/delay.h>`
33			`#include <linux/errno.h>`
34			`#include <linux/fs.h>`
35			`#include <linux/kernel.h>`
36			`#include <linux/major.h>`
37			`#include <linux/slab.h>`
38			`#include <linux/mm.h>`
39			`#include <linux/signal.h>`
40			`#include <linux/types.h>`
41			`#include <linux/i2c.h>`
42			`#include <asm/io.h>`
43			`#include <asm/pgtable.h>`
44			`#include <asm/page.h>`
45			`#include <asm/uaccess.h>`
46
47			`#include <linux/videodev.h>`
48			`#include <linux/video_decoder.h>`
49
50			`MODULE_DESCRIPTION("Philips SAA7111 video decoder driver");`
51			`MODULE_AUTHOR("Dave Perks");`
52			`MODULE_LICENSE("GPL");`
53
54
55			`#define I2C_NAME(s) (s)->name`
56
57
58			`static int debug = 0;`
59			`module_param(debug, int, 0644);`
60			`MODULE_PARM_DESC(debug, "Debug level (0-1)");`
61
62			`#define dprintk(num, format, args...) \`
63			`do { \`
64			`if (debug >= num) \`
65			`printk(format, ##args); \`
66			`} while (0)`
67
68			`/* ----------------------------------------------------------------------- */`
69
70			`#define SAA7111_NR_REG 0x18`
71
72			`struct saa7111 {`
73			`unsigned char reg[SAA7111_NR_REG];`
74
75			`int norm;`
76			`int input;`
77			`int enable;`
78			`};`
79
80			`#define I2C_SAA7111 0x48`
81
82			`/* ----------------------------------------------------------------------- */`
83
84			`static inline int`
85			`saa7111_write (struct i2c_client *client,`
86			`u8 reg,`
87			`u8 value)`
88			`{`
89			`struct saa7111 *decoder = i2c_get_clientdata(client);`
90
91			`decoder->reg[reg] = value;`
92			`return i2c_smbus_write_byte_data(client, reg, value);`
93			`}`
94
95			`static inline void`
96			`saa7111_write_if_changed(struct i2c_client *client, u8 reg, u8 value)`
97			`{`
98			`struct saa7111 *decoder = i2c_get_clientdata(client);`
99
100			`if (decoder->reg[reg] != value) {`
101			`decoder->reg[reg] = value;`
102			`i2c_smbus_write_byte_data(client, reg, value);`
103			`}`
104			`}`
105
106			`static int`
107			`saa7111_write_block (struct i2c_client *client,`
108			`const u8 *data,`
109			`unsigned int len)`
110			`{`
111			`int ret = -1;`
112			`u8 reg;`
113
114			`/* the saa7111 has an autoincrement function, use it if`
115			`* the adapter understands raw I2C */`
116			`if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {`
117			`/* do raw I2C, not smbus compatible */`
118			`struct saa7111 *decoder = i2c_get_clientdata(client);`
119			`u8 block_data[32];`
120			`int block_len;`
121
122			`while (len >= 2) {`
123			`block_len = 0;`
124			`block_data[block_len++] = reg = data[0];`
125			`do {`
126			`block_data[block_len++] =`
127			`decoder->reg[reg++] = data[1];`
128			`len -= 2;`
129			`data += 2;`
130			`} while (len >= 2 && data[0] == reg &&`
131			`block_len < 32);`
132			`if ((ret = i2c_master_send(client, block_data,`
133			`block_len)) < 0)`
134			`break;`
135			`}`
136			`} else {`
137			`/* do some slow I2C emulation kind of thing */`
138			`while (len >= 2) {`
139			`reg = *data++;`
140			`if ((ret = saa7111_write(client, reg,`
141			`*data++)) < 0)`
142			`break;`
143			`len -= 2;`
144			`}`
145			`}`
146
147			`return ret;`
148			`}`
149
150			`static int`
151			`saa7111_init_decoder (struct i2c_client *client,`
152			`struct video_decoder_init *init)`
153			`{`
154			`return saa7111_write_block(client, init->data, init->len);`
155			`}`
156
157			`static inline int`
158			`saa7111_read (struct i2c_client *client,`
159			`u8 reg)`
160			`{`
161			`return i2c_smbus_read_byte_data(client, reg);`
162			`}`
163
164			`/* ----------------------------------------------------------------------- */`
165
166			`static const unsigned char saa7111_i2c_init[] = {`
167			`0x00, 0x00, /* 00 - ID byte */`
168			`0x01, 0x00, /* 01 - reserved */`
169
170			`/front end /`
171			`0x02, 0xd0, /* 02 - FUSE=3, GUDL=2, MODE=0 */`
172			`0x03, 0x23, /* 03 - HLNRS=0, VBSL=1, WPOFF=0,`
173			`* HOLDG=0, GAFIX=0, GAI1=256, GAI2=256 */`
174			`0x04, 0x00, /* 04 - GAI1=256 */`
175			`0x05, 0x00, /* 05 - GAI2=256 */`
176
177			`/* decoder */`
178			`0x06, 0xf3, /* 06 - HSB at 13(50Hz) / 17(60Hz)`
179			`* pixels after end of last line */`
180			`/0x07, 0x13, 07 - HSS at 113(50Hz) / 117(60Hz) pixels`
181			`* after end of last line */`
182			`0x07, 0xe8, /* 07 - HSS seems to be needed to`
183			`* work with NTSC, too */`
184			`0x08, 0xc8, /* 08 - AUFD=1, FSEL=1, EXFIL=0,`
185			`* VTRC=1, HPLL=0, VNOI=0 */`
186			`0x09, 0x01, /* 09 - BYPS=0, PREF=0, BPSS=0,`
187			`* VBLB=0, UPTCV=0, APER=1 */`
188			`0x0a, 0x80, /* 0a - BRIG=128 */`
189			`0x0b, 0x47, /* 0b - CONT=1.109 */`
190			`0x0c, 0x40, /* 0c - SATN=1.0 */`
191			`0x0d, 0x00, /* 0d - HUE=0 */`
192			`0x0e, 0x01, /* 0e - CDTO=0, CSTD=0, DCCF=0,`
193			`* FCTC=0, CHBW=1 */`
194			`0x0f, 0x00, /* 0f - reserved */`
195			`0x10, 0x48, /* 10 - OFTS=1, HDEL=0, VRLN=1, YDEL=0 */`
196			`0x11, 0x1c, /* 11 - GPSW=0, CM99=0, FECO=0, COMPO=1,`
197			`* OEYC=1, OEHV=1, VIPB=0, COLO=0 */`
198			`0x12, 0x00, /* 12 - output control 2 */`
199			`0x13, 0x00, /* 13 - output control 3 */`
200			`0x14, 0x00, /* 14 - reserved */`
201			`0x15, 0x00, /* 15 - VBI */`
202			`0x16, 0x00, /* 16 - VBI */`
203			`0x17, 0x00, /* 17 - VBI */`
204			`};`
205
206			`static int`
207			`saa7111_command (struct i2c_client *client,`
208			`unsigned int cmd,`
209			`void *arg)`
210			`{`
211			`struct saa7111 *decoder = i2c_get_clientdata(client);`
212
213			`switch (cmd) {`
214
215			`case 0:`
216			`break;`
217			`case DECODER_INIT:`
218			`{`
219			`struct video_decoder_init *init = arg;`
220			`if (NULL != init)`
221			`return saa7111_init_decoder(client, init);`
222			`else {`
223			`struct video_decoder_init vdi;`
224			`vdi.data = saa7111_i2c_init;`
225			`vdi.len = sizeof(saa7111_i2c_init);`
226			`return saa7111_init_decoder(client, &vdi);`
227			`}`
228			`}`
229
230			`case DECODER_DUMP:`
231			`{`
232			`int i;`
233
234			`for (i = 0; i < SAA7111_NR_REG; i += 16) {`
235			`int j;`
236
237			`printk(KERN_DEBUG "%s: %03x", I2C_NAME(client), i);`
238			`for (j = 0; j < 16 && i + j < SAA7111_NR_REG; ++j) {`
239			`printk(" %02x",`
240			`saa7111_read(client, i + j));`
241			`}`
242			`printk("\n");`
243			`}`
244			`}`
245			`break;`
246
247			`case DECODER_GET_CAPABILITIES:`
248			`{`
249			`struct video_decoder_capability *cap = arg;`
250
251			`cap->flags = VIDEO_DECODER_PAL \|`
252			`VIDEO_DECODER_NTSC \|`
253			`VIDEO_DECODER_SECAM \|`
254			`VIDEO_DECODER_AUTO \|`
255			`VIDEO_DECODER_CCIR;`
256			`cap->inputs = 8;`
257			`cap->outputs = 1;`
258			`}`
259			`break;`
260
261			`case DECODER_GET_STATUS:`
262			`{`
263			`int *iarg = arg;`
264			`int status;`
265			`int res;`
266
267			`status = saa7111_read(client, 0x1f);`
268			`dprintk(1, KERN_DEBUG "%s status: 0x%02x\n", I2C_NAME(client),`
269			`status);`
270			`res = 0;`
271			`if ((status & (1 << 6)) == 0) {`
272			`res \|= DECODER_STATUS_GOOD;`
273			`}`
274			`switch (decoder->norm) {`
275			`case VIDEO_MODE_NTSC:`
276			`res \|= DECODER_STATUS_NTSC;`
277			`break;`
278			`case VIDEO_MODE_PAL:`
279			`res \|= DECODER_STATUS_PAL;`
280			`break;`
281			`case VIDEO_MODE_SECAM:`
282			`res \|= DECODER_STATUS_SECAM;`
283			`break;`
284			`default:`
285			`case VIDEO_MODE_AUTO:`
286			`if ((status & (1 << 5)) != 0) {`
287			`res \|= DECODER_STATUS_NTSC;`
288			`} else {`
289			`res \|= DECODER_STATUS_PAL;`
290			`}`
291			`break;`
292			`}`
293			`if ((status & (1 << 0)) != 0) {`
294			`res \|= DECODER_STATUS_COLOR;`
295			`}`
296			`*iarg = res;`
297			`}`
298			`break;`
299
300			`case DECODER_SET_GPIO:`
301			`{`
302			`int *iarg = arg;`
303			`if (0 != *iarg) {`
304			`saa7111_write(client, 0x11,`
305			`(decoder->reg[0x11] \| 0x80));`
306			`} else {`
307			`saa7111_write(client, 0x11,`
308			`(decoder->reg[0x11] & 0x7f));`
309			`}`
310			`break;`
311			`}`
312
313			`case DECODER_SET_VBI_BYPASS:`
314			`{`
315			`int *iarg = arg;`
316			`if (0 != *iarg) {`
317			`saa7111_write(client, 0x13,`
318			`(decoder->reg[0x13] & 0xf0) \| 0x0a);`
319			`} else {`
320			`saa7111_write(client, 0x13,`
321			`(decoder->reg[0x13] & 0xf0));`
322			`}`
323			`break;`
324			`}`
325
326			`case DECODER_SET_NORM:`
327			`{`
328			`int *iarg = arg;`
329
330			`switch (*iarg) {`
331
332			`case VIDEO_MODE_NTSC:`
333			`saa7111_write(client, 0x08,`
334			`(decoder->reg[0x08] & 0x3f) \| 0x40);`
335			`saa7111_write(client, 0x0e,`
336			`(decoder->reg[0x0e] & 0x8f));`
337			`break;`
338
339			`case VIDEO_MODE_PAL:`
340			`saa7111_write(client, 0x08,`
341			`(decoder->reg[0x08] & 0x3f) \| 0x00);`
342			`saa7111_write(client, 0x0e,`
343			`(decoder->reg[0x0e] & 0x8f));`
344			`break;`
345
346			`case VIDEO_MODE_SECAM:`
347			`saa7111_write(client, 0x08,`
348			`(decoder->reg[0x08] & 0x3f) \| 0x00);`
349			`saa7111_write(client, 0x0e,`
350			`(decoder->reg[0x0e] & 0x8f) \| 0x50);`
351			`break;`
352
353			`case VIDEO_MODE_AUTO:`
354			`saa7111_write(client, 0x08,`
355			`(decoder->reg[0x08] & 0x3f) \| 0x80);`
356			`saa7111_write(client, 0x0e,`
357			`(decoder->reg[0x0e] & 0x8f));`
358			`break;`
359
360			`default:`
361			`return -EINVAL;`
362
363			`}`
364			`decoder->norm = *iarg;`
365			`}`
366			`break;`
367
368			`case DECODER_SET_INPUT:`
369			`{`
370			`int *iarg = arg;`
371
372			`if (iarg < 0 \|\| iarg > 7) {`
373			`return -EINVAL;`
374			`}`
375
376			`if (decoder->input != *iarg) {`
377			`decoder->input = *iarg;`
378			`/* select mode */`
379			`saa7111_write(client, 0x02,`
380			`(decoder->`
381			`reg[0x02] & 0xf8) \| decoder->input);`
382			`/* bypass chrominance trap for modes 4..7 */`
383			`saa7111_write(client, 0x09,`
384			`(decoder->`
385			`reg[0x09] & 0x7f) \| ((decoder->`
386			`input >`
387			`3) ? 0x80 :`
388			`0));`
389			`}`
390			`}`
391			`break;`
392
393			`case DECODER_SET_OUTPUT:`
394			`{`
395			`int *iarg = arg;`
396
397			`/* not much choice of outputs */`
398			`if (*iarg != 0) {`
399			`return -EINVAL;`
400			`}`
401			`}`
402			`break;`
403
404			`case DECODER_ENABLE_OUTPUT:`
405			`{`
406			`int *iarg = arg;`
407			`int enable = (*iarg != 0);`
408
409			`if (decoder->enable != enable) {`
410			`decoder->enable = enable;`
411
412			`/* RJ: If output should be disabled (for`
413			`* playing videos), we also need a open PLL.`
414			`* The input is set to 0 (where no input`
415			`* source is connected), although this`
416			`* is not necessary.`
417			`*`
418			`* If output should be enabled, we have to`
419			`* reverse the above.`
420			`*/`
421
422			`if (decoder->enable) {`
423			`saa7111_write(client, 0x02,`
424			`(decoder->`
425			`reg[0x02] & 0xf8) \|`
426			`decoder->input);`
427			`saa7111_write(client, 0x08,`
428			`(decoder->reg[0x08] & 0xfb));`
429			`saa7111_write(client, 0x11,`
430			`(decoder->`
431			`reg[0x11] & 0xf3) \| 0x0c);`
432			`} else {`
433			`saa7111_write(client, 0x02,`
434			`(decoder->reg[0x02] & 0xf8));`
435			`saa7111_write(client, 0x08,`
436			`(decoder->`
437			`reg[0x08] & 0xfb) \| 0x04);`
438			`saa7111_write(client, 0x11,`
439			`(decoder->reg[0x11] & 0xf3));`
440			`}`
441			`}`
442			`}`
443			`break;`
444
445			`case DECODER_SET_PICTURE:`
446			`{`
447			`struct video_picture *pic = arg;`
448
449			`/* We want 0 to 255 we get 0-65535 */`
450			`saa7111_write_if_changed(client, 0x0a, pic->brightness >> 8);`
451			`/* We want 0 to 127 we get 0-65535 */`
452			`saa7111_write(client, 0x0b, pic->contrast >> 9);`
453			`/* We want 0 to 127 we get 0-65535 */`
454			`saa7111_write(client, 0x0c, pic->colour >> 9);`
455			`/* We want -128 to 127 we get 0-65535 */`
456			`saa7111_write(client, 0x0d, (pic->hue - 32768) >> 8);`
457			`}`
458			`break;`
459
460			`default:`
461			`return -EINVAL;`
462			`}`
463
464			`return 0;`
465			`}`
466
467			`/* ----------------------------------------------------------------------- */`
468
469			`/*`
470			`* Generic i2c probe`
471			`* concerning the addresses: i2c wants 7 bit (without the r/w bit), so '>>1'`
472			`*/`
473			`static unsigned short normal_i2c[] = { I2C_SAA7111 >> 1, I2C_CLIENT_END };`
474
475			`static unsigned short ignore = I2C_CLIENT_END;`
476
477			`static struct i2c_client_address_data addr_data = {`
478			`.normal_i2c = normal_i2c,`
479			`.probe = &ignore,`
480			`.ignore = &ignore,`
481			`};`
482
483			`static struct i2c_driver i2c_driver_saa7111;`
484
485			`static int`
486			`saa7111_detect_client (struct i2c_adapter *adapter,`
487			`int address,`
488			`int kind)`
489			`{`
490			`int i;`
491			`struct i2c_client *client;`
492			`struct saa7111 *decoder;`
493			`struct video_decoder_init vdi;`
494
495			`dprintk(1,`
496			`KERN_INFO`
497			`"saa7111.c: detecting saa7111 client on address 0x%x\n",`
498			`address << 1);`
499
500			`/* Check if the adapter supports the needed features */`
501			`if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))`
502			`return 0;`
503
504			`client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);`
505			`if (client == 0)`
506			`return -ENOMEM;`
507			`client->addr = address;`
508			`client->adapter = adapter;`
509			`client->driver = &i2c_driver_saa7111;`
510			`strlcpy(I2C_NAME(client), "saa7111", sizeof(I2C_NAME(client)));`
511
512			`decoder = kzalloc(sizeof(struct saa7111), GFP_KERNEL);`
513			`if (decoder == NULL) {`
514			`kfree(client);`
515			`return -ENOMEM;`
516			`}`
517			`decoder->norm = VIDEO_MODE_NTSC;`
518			`decoder->input = 0;`
519			`decoder->enable = 1;`
520			`i2c_set_clientdata(client, decoder);`
521
522			`i = i2c_attach_client(client);`
523			`if (i) {`
524			`kfree(client);`
525			`kfree(decoder);`
526			`return i;`
527			`}`
528
529			`vdi.data = saa7111_i2c_init;`
530			`vdi.len = sizeof(saa7111_i2c_init);`
531			`i = saa7111_init_decoder(client, &vdi);`
532			`if (i < 0) {`
533			`dprintk(1, KERN_ERR "%s_attach error: init status %d\n",`
534			`I2C_NAME(client), i);`
535			`} else {`
536			`dprintk(1,`
537			`KERN_INFO`
538			`"%s_attach: chip version %x at address 0x%x\n",`
539			`I2C_NAME(client), saa7111_read(client, 0x00) >> 4,`
540			`client->addr << 1);`
541			`}`
542
543			`return 0;`
544			`}`
545
546			`static int`
547			`saa7111_attach_adapter (struct i2c_adapter *adapter)`
548			`{`
549			`dprintk(1,`
550			`KERN_INFO`
551			`"saa7111.c: starting probe for adapter %s (0x%x)\n",`
552			`I2C_NAME(adapter), adapter->id);`
553			`return i2c_probe(adapter, &addr_data, &saa7111_detect_client);`
554			`}`
555
556			`static int`
557			`saa7111_detach_client (struct i2c_client *client)`
558			`{`
559			`struct saa7111 *decoder = i2c_get_clientdata(client);`
560			`int err;`
561
562			`err = i2c_detach_client(client);`
563			`if (err) {`
564			`return err;`
565			`}`
566
567			`kfree(decoder);`
568			`kfree(client);`
569
570			`return 0;`
571			`}`
572
573			`/* ----------------------------------------------------------------------- */`
574
575			`static struct i2c_driver i2c_driver_saa7111 = {`
576			`.driver = {`
577			`.name = "saa7111",`
578			`},`
579
580			`.id = I2C_DRIVERID_SAA7111A,`
581
582			`.attach_adapter = saa7111_attach_adapter,`
583			`.detach_client = saa7111_detach_client,`
584			`.command = saa7111_command,`
585			`};`
586
587			`static int __init`
588			`saa7111_init (void)`
589			`{`
590			`return i2c_add_driver(&i2c_driver_saa7111);`
591			`}`
592
593			`static void __exit`
594			`saa7111_exit (void)`
595			`{`
596			`i2c_del_driver(&i2c_driver_saa7111);`
597			`}`
598
599			`module_init(saa7111_init);`
600			`module_exit(saa7111_exit);`