tvp5150.c

au1200的在wince5.0下的摄像头驱动.

Looking for Semester, Diploma or Master Theses on
Operating System Design, Extensible Router Architectures, Network Processor Emulators, Network Protocols and Services,
Contact: Lukas Ruf: <[e-mail]> 



~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~ [ freetext search ] ~ [ file search ] ~ 
PromethOS Cross Reference
Linux/drivers/media/video/tvp5150.c 
Version: ~ [ 2.6.11 ] ~ [ 2.6.14 ] ~ [ 2.6.15 ] ~ [ 2.6.16-rc3 ] ~ 
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~ 


--------------------------------------------------------------------------------

/*
 * tvp5150 - Texas Instruments TVP5150A(M) video decoder driver
 *
 * Copyright (c) 2005 Mauro Carvalho Chehab ([e-mail])
 * This code is placed under the terms of the GNU General Public License
 */

#include <linux/i2c.h>
#include <linux/videodev.h>
#include <linux/delay.h>
#include <linux/video_decoder.h>
#include <media/v4l2-common.h>

#include "tvp5150_reg.h"

MODULE_DESCRIPTION("Texas Instruments TVP5150A video decoder driver");  /* standard i2c insmod options */
MODULE_AUTHOR("Mauro Carvalho Chehab");
MODULE_LICENSE("GPL");

static unsigned short normal_i2c[] = {
        0xb8 >> 1,
        0xba >> 1,
        I2C_CLIENT_END
};

I2C_CLIENT_INSMOD;

static int debug = 0;
module_param(debug, int, 0);
MODULE_PARM_DESC(debug, "Debug level (0-1)");

#define tvp5150_info(fmt, arg...) do { \
        printk(KERN_INFO "%s %d-%04x: " fmt, c->driver->driver.name, \
               i2c_adapter_id(c->adapter), c->addr , ## arg); } while (0)
#define tvp5150_dbg(num, fmt, arg...) \
        do { \
                if (debug >= num) \
                        printk(KERN_DEBUG "%s debug %d-%04x: " fmt,\
                                c->driver->driver.name, \
                                i2c_adapter_id(c->adapter), \
                                c->addr , ## arg); } while (0)

/* supported controls */
static struct v4l2_queryctrl tvp5150_qctrl[] = {
        {
                .id = V4L2_CID_BRIGHTNESS,
                .type = V4L2_CTRL_TYPE_INTEGER,
                .name = "Brightness",
                .minimum = 0,
                .maximum = 255,
                .step = 1,
                .default_value = 0,
                .flags = 0,
        }, {
                .id = V4L2_CID_CONTRAST,
                .type = V4L2_CTRL_TYPE_INTEGER,
                .name = "Contrast",
                .minimum = 0,
                .maximum = 255,
                .step = 0x1,
                .default_value = 0x10,
                .flags = 0,
        }, {
                 .id = V4L2_CID_SATURATION,
                 .type = V4L2_CTRL_TYPE_INTEGER,
                 .name = "Saturation",
                 .minimum = 0,
                 .maximum = 255,
                 .step = 0x1,
                 .default_value = 0x10,
                 .flags = 0,
        }, {
                .id = V4L2_CID_HUE,
                .type = V4L2_CTRL_TYPE_INTEGER,
                .name = "Hue",
                .minimum = -128,
                .maximum = 127,
                .step = 0x1,
                .default_value = 0x10,
                .flags = 0,
        }
};

struct tvp5150 {
        struct i2c_client *client;

        int norm;
        int input;
        int enable;
        int bright;
        int contrast;
        int hue;
        int sat;
};

static int tvp5150_read(struct i2c_client *c, unsigned char addr)
{
        unsigned char buffer[1];
        int rc;

        buffer[0] = addr;
        if (1 != (rc = i2c_master_send(c, buffer, 1)))
                tvp5150_dbg(0, "i2c i/o error: rc == %d (should be 1)\n", rc);

        msleep(10);

        if (1 != (rc = i2c_master_recv(c, buffer, 1)))
                tvp5150_dbg(0, "i2c i/o error: rc == %d (should be 1)\n", rc);

        tvp5150_dbg(2, "tvp5150: read 0x%02x = 0x%02x\n", addr, buffer[0]);

        return (buffer[0]);
}

static inline void tvp5150_write(struct i2c_client *c, unsigned char addr,
                                 unsigned char value)
{
        unsigned char buffer[2];
        int rc;

        buffer[0] = addr;
        buffer[1] = value;
        tvp5150_dbg(2, "tvp5150: writing 0x%02x 0x%02x\n", buffer[0], buffer[1]);
        if (2 != (rc = i2c_master_send(c, buffer, 2)))
                tvp5150_dbg(0, "i2c i/o error: rc == %d (should be 2)\n", rc);
}


/****************************************************************************
                        Basic functions
 ****************************************************************************/
enum tvp5150_input {
        TVP5150_ANALOG_CH0 = 0,
        TVP5150_SVIDEO = 1,
        TVP5150_ANALOG_CH1 = 2,
        TVP5150_BLACK_SCREEN = 8
};

static inline void tvp5150_selmux(struct i2c_client *c,
                                  enum tvp5150_input input)
{
        int opmode=0;

        struct tvp5150 *decoder = i2c_get_clientdata(c);

        if (!decoder->enable)
                input |= TVP5150_BLACK_SCREEN;

        switch (input) {
        case TVP5150_ANALOG_CH0:
        case TVP5150_ANALOG_CH1:
                opmode=0x30;            /* TV Mode */
                break;
        default:
                opmode=0;               /* Auto Mode */
                break;
        }

        tvp5150_write(c, TVP5150_OP_MODE_CTL, opmode);
        tvp5150_write(c, TVP5150_VD_IN_SRC_SEL_1, input);
};

struct i2c_reg_value {
        unsigned char reg;
        unsigned char value;
};

/* Default values as sugested at TVP5150AM1 datasheet */
static const struct i2c_reg_value tvp5150_init_default[] = {
        { /* 0x00 */
                TVP5150_VD_IN_SRC_SEL_1,0x00
        },
        { /* 0x01 */
                TVP5150_ANAL_CHL_CTL,0x15
        },
        { /* 0x02 */
                TVP5150_OP_MODE_CTL,0x00
        },
        { /* 0x03 */
                TVP5150_MISC_CTL,0x01
        },
        { /* 0x06 */
                TVP5150_COLOR_KIL_THSH_CTL,0x10
        },
        { /* 0x07 */
                TVP5150_LUMA_PROC_CTL_1,0x60
        },
        { /* 0x08 */
                TVP5150_LUMA_PROC_CTL_2,0x00
        },
        { /* 0x09 */
                TVP5150_BRIGHT_CTL,0x80
        },
        { /* 0x0a */
                TVP5150_SATURATION_CTL,0x80
        },
        { /* 0x0b */
                TVP5150_HUE_CTL,0x00
        },
        { /* 0x0c */
                TVP5150_CONTRAST_CTL,0x80
        },
        { /* 0x0d */
                TVP5150_DATA_RATE_SEL,0x47
        },
        { /* 0x0e */
                TVP5150_LUMA_PROC_CTL_3,0x00
        },
        { /* 0x0f */
                TVP5150_CONF_SHARED_PIN,0x08
        },
        { /* 0x11 */
                TVP5150_ACT_VD_CROP_ST_MSB,0x00
        },
        { /* 0x12 */
                TVP5150_ACT_VD_CROP_ST_LSB,0x00
        },
        { /* 0x13 */
                TVP5150_ACT_VD_CROP_STP_MSB,0x00
        },
        { /* 0x14 */
                TVP5150_ACT_VD_CROP_STP_LSB,0x00
        },
        { /* 0x15 */
                TVP5150_GENLOCK,0x01
        },
        { /* 0x16 */
                TVP5150_HORIZ_SYNC_START,0x80
        },
        { /* 0x18 */
                TVP5150_VERT_BLANKING_START,0x00
        },
        { /* 0x19 */
                TVP5150_VERT_BLANKING_STOP,0x00
        },
        { /* 0x1a */
                TVP5150_CHROMA_PROC_CTL_1,0x0c
        },
        { /* 0x1b */
                TVP5150_CHROMA_PROC_CTL_2,0x14
        },
        { /* 0x1c */
                TVP5150_INT_RESET_REG_B,0x00
        },
        { /* 0x1d */
                TVP5150_INT_ENABLE_REG_B,0x00
        },
        { /* 0x1e */
                TVP5150_INTT_CONFIG_REG_B,0x00
        },
        { /* 0x28 */
                TVP5150_VIDEO_STD,0x00
        },
        { /* 0x2e */
                TVP5150_MACROVISION_ON_CTR,0x0f
        },
        { /* 0x2f */
                TVP5150_MACROVISION_OFF_CTR,0x01
        },
        { /* 0xbb */
                TVP5150_TELETEXT_FIL_ENA,0x00
        },
        { /* 0xc0 */
                TVP5150_INT_STATUS_REG_A,0x00
        },
        { /* 0xc1 */
                TVP5150_INT_ENABLE_REG_A,0x00
        },
        { /* 0xc2 */
                TVP5150_INT_CONF,0x04
        },
        { /* 0xc8 */
                TVP5150_FIFO_INT_THRESHOLD,0x80
        },
        { /* 0xc9 */
                TVP5150_FIFO_RESET,0x00
        },
        { /* 0xca */
                TVP5150_LINE_NUMBER_INT,0x00
        },
        { /* 0xcb */
                TVP5150_PIX_ALIGN_REG_LOW,0x4e
        },
        { /* 0xcc */
                TVP5150_PIX_ALIGN_REG_HIGH,0x00
        },
        { /* 0xcd */
                TVP5150_FIFO_OUT_CTRL,0x01
        },
        { /* 0xcf */
                TVP5150_FULL_FIELD_ENA_1,0x00
        },
        { /* 0xd0 */
                TVP5150_FULL_FIELD_ENA_2,0x00
        },
        { /* 0xfc */
                TVP5150_FULL_FIELD_MODE_REG,0x7f
        },
        { /* end of data */
                0xff,0xff
        }
};

/* Default values as sugested at TVP5150AM1 datasheet */
static const struct i2c_reg_value tvp5150_init_enable[] = {
        {
                TVP5150_CONF_SHARED_PIN, 2
        },{     /* Automatic offset and AGC enabled */
                TVP5150_ANAL_CHL_CTL, 0x15
        },{     /* Activate YCrCb output 0x9 or 0xd ? */
                TVP5150_MISC_CTL, 0x6f
        },{     /* Activates video std autodetection for all standards */
                TVP5150_AUTOSW_MSK, 0x0
        },{     /* Default format: 0x47. For 4:2:2: 0x40 */
                TVP5150_DATA_RATE_SEL, 0x47
        },{
                TVP5150_CHROMA_PROC_CTL_1, 0x0c
        },{
                TVP5150_CHROMA_PROC_CTL_2, 0x54
        },{     /* Non documented, but initialized on WinTV USB2 */
                0x27, 0x20
        },{
                0xff,0xff
        }
};

struct i2c_vbi_ram_value {
        u16 reg;
        unsigned char values[26];
};

static struct i2c_vbi_ram_value vbi_ram_default[] =
{
        {0x010, /* WST SECAM 6 */
                { 0xaa, 0xaa, 0xff, 0xff , 0xe7, 0x2e, 0x20, 0x26, 0xe6, 0xb4, 0x0e, 0x0, 0x0, 0x0, 0x10, 0x0 }
        },
        {0x030, /* WST PAL B 6 */
                { 0xaa, 0xaa, 0xff, 0xff , 0x27, 0x2e, 0x20, 0x2b, 0xa6, 0x72, 0x10, 0x0, 0x0, 0x0, 0x10, 0x0 }
        },
        {0x050, /* WST PAL C 6 */
                { 0xaa, 0xaa, 0xff, 0xff , 0xe7, 0x2e, 0x20, 0x22, 0xa6, 0x98, 0x0d, 0x0, 0x0, 0x0, 0x10, 0x0 }
        },
        {0x070, /* WST NTSC 6 */
                { 0xaa, 0xaa, 0xff, 0xff , 0x27, 0x2e, 0x20, 0x23, 0x69, 0x93, 0x0d, 0x0, 0x0, 0x0, 0x10, 0x0 }
        },
        {0x090, /* NABTS, NTSC 6 */
                { 0xaa, 0xaa, 0xff, 0xff , 0xe7, 0x2e, 0x20, 0x22, 0x69, 0x93, 0x0d, 0x0, 0x0, 0x0, 0x15, 0x0 }
        },
        {0x0b0, /* NABTS, NTSC-J 6 */
                { 0xaa, 0xaa, 0xff, 0xff , 0xa7, 0x2e, 0x20, 0x23, 0x69, 0x93, 0x0d, 0x0, 0x0, 0x0, 0x10, 0x0 }
        },
        {0x0d0, /* CC, PAL/SECAM 6 */
                { 0xaa, 0x2a, 0xff, 0x3f , 0x04, 0x51, 0x6e, 0x02, 0xa6, 0x7b, 0x09, 0x0, 0x0, 0x0, 0x27, 0x0 }
        },
        {0x0f0, /* CC, NTSC 6 */
                { 0xaa, 0x2a, 0xff, 0x3f , 0x04, 0x51, 0x6e, 0x02, 0x69, 0x8c, 0x09, 0x0, 0x0, 0x0, 0x27, 0x0 }
        },
        {0x110, /* WSS, PAL/SECAM 6 */
                { 0x5b, 0x55, 0xc5, 0xff , 0x0, 0x71, 0x6e, 0x42, 0xa6, 0xcd, 0x0f, 0x0, 0x0, 0x0, 0x3a, 0x0 }
        },
        {0x130, /* WSS, NTSC C */
                { 0x38, 0x00, 0x3f, 0x00 , 0x0, 0x71, 0x6e, 0x43, 0x69, 0x7c, 0x08, 0x0, 0x0, 0x0, 0x39, 0x0 }
        },
        {0x150, /* VITC, PAL/SECAM 6 */
                { 0x0, 0x0, 0x0, 0x0 , 0x0, 0x8f, 0x6d, 0x49, 0xa6, 0x85, 0x08, 0x0, 0x0, 0x0, 0x4c, 0x0 }
        },
        {0x170, /* VITC, NTSC 6 */
                { 0x0, 0x0, 0x0, 0x0 , 0x0, 0x8f, 0x6d, 0x49, 0x69, 0x94, 0x08, 0x0, 0x0, 0x0, 0x4c, 0x0 }
        },
        { (u16)-1 }
};

static int tvp5150_write_inittab(struct i2c_client *c,
                                 const struct i2c_reg_value *regs)
{
        while (regs->reg != 0xff) {
                tvp5150_write(c, regs->reg, regs->value);
                regs++;
        }
        return 0;
}

static int tvp5150_vdp_init(struct i2c_client *c,
                                 const struct i2c_vbi_ram_value *regs)
{
        unsigned int i;

        /* Disable Full Field */
        tvp5150_write(c, TVP5150_FULL_FIELD_ENA_1, 0);

        /* Before programming, Line mode should be at 0xff */
        for (i=TVP5150_FULL_FIELD_ENA_2; i<=TVP5150_LINE_MODE_REG_44; i++)
                tvp5150_write(c, i, 0xff);

        /* Load Ram Table */
        while (regs->reg != (u16)-1 ) {
                tvp5150_write(c, TVP5150_CONF_RAM_ADDR_HIGH,regs->reg>>8);
                tvp5150_write(c, TVP5150_CONF_RAM_ADDR_LOW,regs->reg);

                for (i=0;i<16;i++)
                        tvp5150_write(c, TVP5150_VDP_CONF_RAM_DATA,regs->values[i]);

                regs++;
        }
        return 0;
}

static int tvp5150_set_std(struct i2c_client *c, v4l2_std_id std)
{
        struct tvp5150 *decoder = i2c_get_clientdata(c);
        int fmt=0;

        decoder->norm=std;

        /* First tests should be against specific std */

        if (std == V4L2_STD_ALL) {
                fmt=0;  /* Autodetect mode */
        } else if (std & V4L2_STD_NTSC_443) {
                fmt=0xa;
        } else if (std & V4L2_STD_PAL_M) {
                fmt=0x6;
        } else if (std & (V4L2_STD_PAL_N| V4L2_STD_PAL_Nc)) {
                fmt=0x8;
        } else {
                /* Then, test against generic ones */
                if (std & V4L2_STD_NTSC) {
                        fmt=0x2;
                } else if (std & V4L2_STD_PAL) {
                        fmt=0x4;
                } else if (std & V4L2_STD_SECAM) {
                        fmt=0xc;
                }
        }