leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity
b3d5496ea5
linux/drivers/media/video/vpx3220.c
Jean Delvare b3d5496ea5 [PATCH] I2C: Kill address ranges in non-sensors i2c chip drivers 
Some months ago, you killed the address ranges mechanism from all
sensors i2c chip drivers (both the module parameters and the in-code
address lists). I think it was a very good move, as the ranges can
easily be replaced by individual addresses, and this allowed for
significant cleanups in the i2c core (let alone the impressive size
shrink for all these drivers).

Unfortunately you did not do the same for non-sensors i2c chip drivers.
These need the address ranges even less, so we could get rid of the
ranges here as well for another significant i2c core cleanup. Here comes
a patch which does just that. Since the process is exactly the same as
what you did for the other drivers set already, I did not split this one
in parts.

A documentation update is included.

The change saves 308 bytes in the i2c core, and an average 1382 bytes
for chip drivers which use I2C_CLIENT_INSMOD, 126 bytes for those which
do not.

This change is required if we want to merge the sensors and non-sensors
i2c code (and we want to do this).

Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

Index: gregkh-2.6/Documentation/i2c/writing-clients
===================================================================
2005-06-21 21:51:48 -07:00

749 lines
17 KiB
C
Raw Blame History

/*
* vpx3220a, vpx3216b & vpx3214c video decoder driver version 0.0.1
*
* Copyright (C) 2001 Laurent Pinchart <lpinchart@freegates.be>
*
* 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/types.h>
#include <linux/slab.h>
#include <linux/byteorder/swab.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <linux/i2c.h>
#include <linux/i2c-dev.h>
#define I2C_NAME(x) (x)->name
#include <linux/videodev.h>
#include <linux/video_decoder.h>
#define I2C_VPX3220 0x86
#define VPX3220_DEBUG KERN_DEBUG "vpx3220: "
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)
#define VPX_TIMEOUT_COUNT 10
/* ----------------------------------------------------------------------- */
struct vpx3220 {
unsigned char reg[255];
int norm;
int input;
int enable;
int bright;
int contrast;
int hue;
int sat;
};
static char *inputs[] = { "internal", "composite", "svideo" };
/* ----------------------------------------------------------------------- */
static inline int
vpx3220_write (struct i2c_client *client,
u8 reg,
u8 value)
{
struct vpx3220 *decoder = i2c_get_clientdata(client);
decoder->reg[reg] = value;
return i2c_smbus_write_byte_data(client, reg, value);
}
static inline int
vpx3220_read (struct i2c_client *client,
u8 reg)
{
return i2c_smbus_read_byte_data(client, reg);
}
static int
vpx3220_fp_status (struct i2c_client *client)
{
unsigned char status;
unsigned int i;
for (i = 0; i < VPX_TIMEOUT_COUNT; i++) {
status = vpx3220_read(client, 0x29);
if (!(status & 4))
return 0;
udelay(10);
if (need_resched())
cond_resched();
}
return -1;
}
static int
vpx3220_fp_write (struct i2c_client *client,
u8 fpaddr,
u16 data)
{
/* Write the 16-bit address to the FPWR register */
if (i2c_smbus_write_word_data(client, 0x27, swab16(fpaddr)) == -1) {
dprintk(1, VPX3220_DEBUG "%s: failed\n", __func__);
return -1;
}
if (vpx3220_fp_status(client) < 0)
return -1;
/* Write the 16-bit data to the FPDAT register */
if (i2c_smbus_write_word_data(client, 0x28, swab16(data)) == -1) {
dprintk(1, VPX3220_DEBUG "%s: failed\n", __func__);
return -1;
}
return 0;
}
static u16
vpx3220_fp_read (struct i2c_client *client,
u16 fpaddr)
{
s16 data;
/* Write the 16-bit address to the FPRD register */
if (i2c_smbus_write_word_data(client, 0x26, swab16(fpaddr)) == -1) {
dprintk(1, VPX3220_DEBUG "%s: failed\n", __func__);
return -1;
}
if (vpx3220_fp_status(client) < 0)
return -1;
/* Read the 16-bit data from the FPDAT register */
data = i2c_smbus_read_word_data(client, 0x28);
if (data == -1) {
dprintk(1, VPX3220_DEBUG "%s: failed\n", __func__);
return -1;
}
return swab16(data);
}
static int
vpx3220_write_block (struct i2c_client *client,
const u8 *data,
unsigned int len)
{
u8 reg;
int ret = -1;
while (len >= 2) {
reg = *data++;
if ((ret =
vpx3220_write(client, reg, *data++)) < 0)
break;
len -= 2;
}
return ret;
}
static int
vpx3220_write_fp_block (struct i2c_client *client,
const u16 *data,
unsigned int len)
{
u8 reg;
int ret = 0;
while (len > 1) {
reg = *data++;
ret |= vpx3220_fp_write(client, reg, *data++);
len -= 2;
}
return ret;
}
/* ---------------------------------------------------------------------- */
static const unsigned short init_ntsc[] = {
0x1c, 0x00, /* NTSC tint angle */
0x88, 17, /* Window 1 vertical */
0x89, 240, /* Vertical lines in */
0x8a, 240, /* Vertical lines out */
0x8b, 000, /* Horizontal begin */
0x8c, 640, /* Horizontal length */
0x8d, 640, /* Number of pixels */
0x8f, 0xc00, /* Disable window 2 */
0xf0, 0x173, /* 13.5 MHz transport, Forced
* mode, latch windows */
0xf2, 0x13, /* NTSC M, composite input */
0xe7, 0x1e1, /* Enable vertical standard
* locking @ 240 lines */
};
static const unsigned short init_pal[] = {
0x88, 23, /* Window 1 vertical begin */
0x89, 288 + 16, /* Vertical lines in (16 lines
* skipped by the VFE) */
0x8a, 288 + 16, /* Vertical lines out (16 lines
* skipped by the VFE) */
0x8b, 16, /* Horizontal begin */
0x8c, 768, /* Horizontal length */
0x8d, 784, /* Number of pixels
* Must be >= Horizontal begin + Horizontal length */
0x8f, 0xc00, /* Disable window 2 */
0xf0, 0x177, /* 13.5 MHz transport, Forced
* mode, latch windows */
0xf2, 0x3d1, /* PAL B,G,H,I, composite input */
0xe7, 0x261, /* PAL/SECAM set to 288 + 16 lines
* change to 0x241 for 288 lines */
};
static const unsigned short init_secam[] = {
0x88, 23 - 16, /* Window 1 vertical begin */
0x89, 288 + 16, /* Vertical lines in (16 lines
* skipped by the VFE) */
0x8a, 288 + 16, /* Vertical lines out (16 lines
* skipped by the VFE) */
0x8b, 16, /* Horizontal begin */
0x8c, 768, /* Horizontal length */
0x8d, 784, /* Number of pixels
* Must be >= Horizontal begin + Horizontal length */
0x8f, 0xc00, /* Disable window 2 */
0xf0, 0x177, /* 13.5 MHz transport, Forced
* mode, latch windows */
0xf2, 0x3d5, /* SECAM, composite input */
0xe7, 0x261, /* PAL/SECAM set to 288 + 16 lines
* change to 0x241 for 288 lines */
};
static const unsigned char init_common[] = {
0xf2, 0x00, /* Disable all outputs */
0x33, 0x0d, /* Luma : VIN2, Chroma : CIN
* (clamp off) */
0xd8, 0xa8, /* HREF/VREF active high, VREF
* pulse = 2, Odd/Even flag */
0x20, 0x03, /* IF compensation 0dB/oct */
0xe0, 0xff, /* Open up all comparators */
0xe1, 0x00,
0xe2, 0x7f,
0xe3, 0x80,
0xe4, 0x7f,
0xe5, 0x80,
0xe6, 0x00, /* Brightness set to 0 */
0xe7, 0xe0, /* Contrast to 1.0, noise shaping
* 10 to 8 2-bit error diffusion */
0xe8, 0xf8, /* YUV422, CbCr binary offset,
* ... (p.32) */
0xea, 0x18, /* LLC2 connected, output FIFO
* reset with VACTintern */
0xf0, 0x8a, /* Half full level to 10, bus
* shuffler [7:0, 23:16, 15:8] */
0xf1, 0x18, /* Single clock, sync mode, no
* FE delay, no HLEN counter */
0xf8, 0x12, /* Port A, PIXCLK, HF# & FE#
* strength to 2 */
0xf9, 0x24, /* Port B, HREF, VREF, PREF &
* ALPHA strength to 4 */
};
static const unsigned short init_fp[] = {
0x59, 0,
0xa0, 2070, /* ACC reference */
0xa3, 0,
0xa4, 0,
0xa8, 30,
0xb2, 768,
0xbe, 27,
0x58, 0,
0x26, 0,
0x4b, 0x298, /* PLL gain */
};
static void
vpx3220_dump_i2c (struct i2c_client *client)
{
int len = sizeof(init_common);
const unsigned char *data = init_common;
while (len > 1) {
dprintk(1,
KERN_DEBUG "vpx3216b i2c reg 0x%02x data 0x%02x\n",
*data, vpx3220_read(client, *data));
data += 2;
len -= 2;
}
}
static int
vpx3220_command (struct i2c_client *client,
unsigned int cmd,
void *arg)
{
struct vpx3220 *decoder = i2c_get_clientdata(client);
switch (cmd) {
case 0:
{
vpx3220_write_block(client, init_common,
sizeof(init_common));
vpx3220_write_fp_block(client, init_fp,
sizeof(init_fp) >> 1);
switch (decoder->norm) {
case VIDEO_MODE_NTSC:
vpx3220_write_fp_block(client, init_ntsc,
sizeof(init_ntsc) >> 1);
break;
case VIDEO_MODE_PAL:
vpx3220_write_fp_block(client, init_pal,
sizeof(init_pal) >> 1);
break;
case VIDEO_MODE_SECAM:
vpx3220_write_fp_block(client, init_secam,
sizeof(init_secam) >> 1);
break;
default:
vpx3220_write_fp_block(client, init_pal,
sizeof(init_pal) >> 1);
break;
}
}
break;
case DECODER_DUMP:
{
vpx3220_dump_i2c(client);
}
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_SECAM |
VIDEO_DECODER_AUTO |
VIDEO_DECODER_CCIR;
cap->inputs = 3;
cap->outputs = 1;
}
break;
case DECODER_GET_STATUS:
{
int res = 0, status;
dprintk(1, KERN_INFO "%s: DECODER_GET_STATUS\n",
I2C_NAME(client));
status = vpx3220_fp_read(client, 0x0f3);
dprintk(1, KERN_INFO "%s: status: 0x%04x\n", I2C_NAME(client),
status);
if (status < 0)
return status;
if ((status & 0x20) == 0) {
res |= DECODER_STATUS_GOOD | DECODER_STATUS_COLOR;
switch (status & 0x18) {
case 0x00:
case 0x10:
case 0x14:
case 0x18:
res |= DECODER_STATUS_PAL;
break;
case 0x08:
res |= DECODER_STATUS_SECAM;
break;
case 0x04:
case 0x0c:
case 0x1c:
res |= DECODER_STATUS_NTSC;
break;
}
}
*(int *) arg = res;
}
break;
case DECODER_SET_NORM:
{
int *iarg = arg, data;
dprintk(1, KERN_DEBUG "%s: DECODER_SET_NORM %d\n",
I2C_NAME(client), *iarg);
switch (*iarg) {
case VIDEO_MODE_NTSC:
vpx3220_write_fp_block(client, init_ntsc,
sizeof(init_ntsc) >> 1);
dprintk(1, KERN_INFO "%s: norm switched to NTSC\n",
I2C_NAME(client));
break;
case VIDEO_MODE_PAL:
vpx3220_write_fp_block(client, init_pal,
sizeof(init_pal) >> 1);
dprintk(1, KERN_INFO "%s: norm switched to PAL\n",
I2C_NAME(client));
break;
case VIDEO_MODE_SECAM:
vpx3220_write_fp_block(client, init_secam,
sizeof(init_secam) >> 1);
dprintk(1, KERN_INFO "%s: norm switched to SECAM\n",
I2C_NAME(client));
break;
case VIDEO_MODE_AUTO:
/* FIXME This is only preliminary support */
data = vpx3220_fp_read(client, 0xf2) & 0x20;
vpx3220_fp_write(client, 0xf2, 0x00c0 | data);
dprintk(1, KERN_INFO "%s: norm switched to Auto\n",
I2C_NAME(client));
break;
default:
return -EINVAL;
}
decoder->norm = *iarg;
}
break;
case DECODER_SET_INPUT:
{
int *iarg = arg, data;
/* RJ: *iarg = 0: ST8 (PCTV) input
*iarg = 1: COMPOSITE input
*iarg = 2: SVHS input */
const int input[3][2] = {
{0x0c, 0},
{0x0d, 0},
{0x0e, 1}
};
if (*iarg < 0 || *iarg > 2)
return -EINVAL;
dprintk(1, KERN_INFO "%s: input switched to %s\n",
I2C_NAME(client), inputs[*iarg]);
vpx3220_write(client, 0x33, input[*iarg][0]);
data = vpx3220_fp_read(client, 0xf2) & ~(0x0020);
if (data < 0)
return data;
/* 0x0010 is required to latch the setting */
vpx3220_fp_write(client, 0xf2,
data | (input[*iarg][1] << 5) | 0x0010);
udelay(10);
}
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;
dprintk(1, KERN_DEBUG "%s: DECODER_ENABLE_OUTPUT %d\n",
I2C_NAME(client), *iarg);
vpx3220_write(client, 0xf2, (*iarg ? 0x1b : 0x00));
}
break;
case DECODER_SET_PICTURE:
{
struct video_picture *pic = arg;
if (decoder->bright != pic->brightness) {
/* We want -128 to 128 we get 0-65535 */
decoder->bright = pic->brightness;
vpx3220_write(client, 0xe6,
(decoder->bright - 32768) >> 8);
}
if (decoder->contrast != pic->contrast) {
/* We want 0 to 64 we get 0-65535 */
/* Bit 7 and 8 is for noise shaping */
decoder->contrast = pic->contrast;
vpx3220_write(client, 0xe7,
(decoder->contrast >> 10) + 192);
}
if (decoder->sat != pic->colour) {
/* We want 0 to 4096 we get 0-65535 */
decoder->sat = pic->colour;
vpx3220_fp_write(client, 0xa0,
decoder->sat >> 4);
}
if (decoder->hue != pic->hue) {
/* We want -512 to 512 we get 0-65535 */
decoder->hue = pic->hue;
vpx3220_fp_write(client, 0x1c,
((decoder->hue - 32768) >> 6) & 0xFFF);
}
}
break;
default:
return -EINVAL;
}
return 0;
}
static int
vpx3220_init_client (struct i2c_client *client)
{
vpx3220_write_block(client, init_common, sizeof(init_common));
vpx3220_write_fp_block(client, init_fp, sizeof(init_fp) >> 1);
/* Default to PAL */
vpx3220_write_fp_block(client, init_pal, sizeof(init_pal) >> 1);
return 0;
}
/* -----------------------------------------------------------------------
* Client managment code
*/
/*
* Generic i2c probe
* concerning the addresses: i2c wants 7 bit (without the r/w bit), so '>>1'
*/
static unsigned short normal_i2c[] =
{ I2C_VPX3220 >> 1, (I2C_VPX3220 >> 1) + 4,
I2C_CLIENT_END
};
static unsigned short probe[2] = { I2C_CLIENT_END, I2C_CLIENT_END };
static unsigned short ignore[2] = { I2C_CLIENT_END, I2C_CLIENT_END };
static unsigned short force[2] = { I2C_CLIENT_END , I2C_CLIENT_END };
static struct i2c_client_address_data addr_data = {
.normal_i2c = normal_i2c,
.probe = probe,
.ignore = ignore,
.force = force
};
static struct i2c_driver vpx3220_i2c_driver;
static int
vpx3220_detach_client (struct i2c_client *client)
{
struct vpx3220 *decoder = i2c_get_clientdata(client);
int err;
err = i2c_detach_client(client);
if (err) {
return err;
}
kfree(decoder);
kfree(client);
return 0;
}
static int
vpx3220_detect_client (struct i2c_adapter *adapter,
int address,
int kind)
{
int err;
struct i2c_client *client;
struct vpx3220 *decoder;
dprintk(1, VPX3220_DEBUG "%s\n", __func__);
/* Check if the adapter supports the needed features */
if (!i2c_check_functionality
(adapter, I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
return 0;
client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
if (client == NULL) {
return -ENOMEM;
}
memset(client, 0, sizeof(struct i2c_client));
client->addr = address;
client->adapter = adapter;
client->driver = &vpx3220_i2c_driver;
client->flags = I2C_CLIENT_ALLOW_USE;
/* Check for manufacture ID and part number */
if (kind < 0) {
u8 id;
u16 pn;
id = vpx3220_read(client, 0x00);
if (id != 0xec) {
dprintk(1,
KERN_INFO
"vpx3220_attach: Wrong manufacturer ID (0x%02x)\n",
id);
kfree(client);
return 0;
}
pn = (vpx3220_read(client, 0x02) << 8) +
vpx3220_read(client, 0x01);
switch (pn) {
case 0x4680:
strlcpy(I2C_NAME(client), "vpx3220a",
sizeof(I2C_NAME(client)));
break;
case 0x4260:
strlcpy(I2C_NAME(client), "vpx3216b",
sizeof(I2C_NAME(client)));
break;
case 0x4280:
strlcpy(I2C_NAME(client), "vpx3214c",
sizeof(I2C_NAME(client)));
break;
default:
dprintk(1,
KERN_INFO
"%s: Wrong part number (0x%04x)\n",
__func__, pn);
kfree(client);
return 0;
}
} else {
strlcpy(I2C_NAME(client), "forced vpx32xx",
sizeof(I2C_NAME(client)));
}
decoder = kmalloc(sizeof(struct vpx3220), GFP_KERNEL);
if (decoder == NULL) {
kfree(client);
return -ENOMEM;
}
memset(decoder, 0, sizeof(struct vpx3220));
decoder->norm = VIDEO_MODE_PAL;
decoder->input = 0;
decoder->enable = 1;
decoder->bright = 32768;
decoder->contrast = 32768;
decoder->hue = 32768;
decoder->sat = 32768;
i2c_set_clientdata(client, decoder);
err = i2c_attach_client(client);
if (err) {
kfree(client);
kfree(decoder);
return err;
}
dprintk(1, KERN_INFO "%s: vpx32xx client found at address 0x%02x\n",
I2C_NAME(client), client->addr << 1);
vpx3220_init_client(client);
return 0;
}
static int
vpx3220_attach_adapter (struct i2c_adapter *adapter)
{
int ret;
ret = i2c_probe(adapter, &addr_data, &vpx3220_detect_client);
dprintk(1, VPX3220_DEBUG "%s: i2c_probe returned %d\n",
__func__, ret);
return ret;
}
/* -----------------------------------------------------------------------
* Driver initialization and cleanup code
*/
static struct i2c_driver vpx3220_i2c_driver = {
.owner = THIS_MODULE,
.name = "vpx3220",
.id = I2C_DRIVERID_VPX3220,
.flags = I2C_DF_NOTIFY,
.attach_adapter = vpx3220_attach_adapter,
.detach_client = vpx3220_detach_client,
.command = vpx3220_command,
};
static int __init
vpx3220_init (void)
{
return i2c_add_driver(&vpx3220_i2c_driver);
}
static void __exit
vpx3220_cleanup (void)
{
i2c_del_driver(&vpx3220_i2c_driver);
}
module_init(vpx3220_init);
module_exit(vpx3220_cleanup);
MODULE_DESCRIPTION("vpx3220a/vpx3216b/vpx3214c video encoder driver");
MODULE_AUTHOR("Laurent Pinchart");
MODULE_LICENSE("GPL");
Reference in New Issue View Git Blame Copy Permalink