release/src-rt-6.x.4708/linux/linux-2.6.36/drivers/media/video/bt866.c

   1 /*
   2     bt866 - BT866 Digital Video Encoder (Rockwell Part)
   3
   4     Copyright (C) 1999 Mike Bernson <mike@mlb.org>
   5     Copyright (C) 1998 Dave Perks <dperks@ibm.net>
   6
   7     Modifications for LML33/DC10plus unified driver
   8     Copyright (C) 2000 Serguei Miridonov <mirsev@cicese.mx>
   9
  10     This code was modify/ported from the saa7111 driver written
  11     by Dave Perks.
  12
  13     This code was adapted for the bt866 by Christer Weinigel and ported
  14     to 2.6 by Martin Samuelsson.
  15
  16     This program is free software; you can redistribute it and/or modify
  17     it under the terms of the GNU General Public License as published by
  18     the Free Software Foundation; either version 2 of the License, or
  19     (at your option) any later version.
  20
  21     This program is distributed in the hope that it will be useful,
  22     but WITHOUT ANY WARRANTY; without even the implied warranty of
  23     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24     GNU General Public License for more details.
  25
  26     You should have received a copy of the GNU General Public License
  27     along with this program; if not, write to the Free Software
  28     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  29 */
  30
  31 #include <linux/module.h>
  32 #include <linux/types.h>
  33 #include <linux/slab.h>
  34 #include <linux/ioctl.h>
  35 #include <asm/uaccess.h>
  36 #include <linux/i2c.h>
  37 #include <linux/i2c-id.h>
  38 #include <linux/videodev2.h>
  39 #include <media/v4l2-device.h>
  40 #include <media/v4l2-chip-ident.h>
  41 #include <media/v4l2-i2c-drv.h>
  42
  43 MODULE_DESCRIPTION("Brooktree-866 video encoder driver");
  44 MODULE_AUTHOR("Mike Bernson & Dave Perks");
  45 MODULE_LICENSE("GPL");
  46
  47 static int debug;
  48 module_param(debug, int, 0);
  49 MODULE_PARM_DESC(debug, "Debug level (0-1)");
  50
  51
  52 /* ----------------------------------------------------------------------- */
  53
  54 struct bt866 {
  55         struct v4l2_subdev sd;
  56         u8 reg[256];
  57 };
  58
  59 static inline struct bt866 *to_bt866(struct v4l2_subdev *sd)
  60 {
  61         return container_of(sd, struct bt866, sd);
  62 }
  63
  64 static int bt866_write(struct bt866 *encoder, u8 subaddr, u8 data)
  65 {
  66         struct i2c_client *client = v4l2_get_subdevdata(&encoder->sd);
  67         u8 buffer[2];
  68         int err;
  69
  70         buffer[0] = subaddr;
  71         buffer[1] = data;
  72
  73         encoder->reg[subaddr] = data;
  74
  75         v4l_dbg(1, debug, client, "write 0x%02x = 0x%02x\n", subaddr, data);
  76
  77         for (err = 0; err < 3;) {
  78                 if (i2c_master_send(client, buffer, 2) == 2)
  79                         break;
  80                 err++;
  81                 v4l_warn(client, "error #%d writing to 0x%02x\n",
  82                                 err, subaddr);
  83                 schedule_timeout_interruptible(msecs_to_jiffies(100));
  84         }
  85         if (err == 3) {
  86                 v4l_warn(client, "giving up\n");
  87                 return -1;
  88         }
  89
  90         return 0;
  91 }
  92
  93 static int bt866_s_std_output(struct v4l2_subdev *sd, v4l2_std_id std)
  94 {
  95         v4l2_dbg(1, debug, sd, "set norm %llx\n", (unsigned long long)std);
  96
  97         /* Only PAL supported by this driver at the moment! */
  98         if (!(std & V4L2_STD_NTSC))
  99                 return -EINVAL;
 100         return 0;
 101 }
 102
 103 static int bt866_s_routing(struct v4l2_subdev *sd,
 104                            u32 input, u32 output, u32 config)
 105 {
 106         static const __u8 init[] = {
 107                 0xc8, 0xcc, /* CRSCALE */
 108                 0xca, 0x91, /* CBSCALE */
 109                 0xcc, 0x24, /* YC16 | OSDNUM */
 110                 0xda, 0x00, /*  */
 111                 0xdc, 0x24, /* SETMODE | PAL */
 112                 0xde, 0x02, /* EACTIVE */
 113
 114                 /* overlay colors */
 115                 0x70, 0xEB, 0x90, 0x80, 0xB0, 0x80, /* white */
 116                 0x72, 0xA2, 0x92, 0x8E, 0xB2, 0x2C, /* yellow */
 117                 0x74, 0x83, 0x94, 0x2C, 0xB4, 0x9C, /* cyan */
 118                 0x76, 0x70, 0x96, 0x3A, 0xB6, 0x48, /* green */
 119                 0x78, 0x54, 0x98, 0xC6, 0xB8, 0xB8, /* magenta */
 120                 0x7A, 0x41, 0x9A, 0xD4, 0xBA, 0x64, /* red */
 121                 0x7C, 0x23, 0x9C, 0x72, 0xBC, 0xD4, /* blue */
 122                 0x7E, 0x10, 0x9E, 0x80, 0xBE, 0x80, /* black */
 123
 124                 0x60, 0xEB, 0x80, 0x80, 0xc0, 0x80, /* white */
 125                 0x62, 0xA2, 0x82, 0x8E, 0xc2, 0x2C, /* yellow */
 126                 0x64, 0x83, 0x84, 0x2C, 0xc4, 0x9C, /* cyan */
 127                 0x66, 0x70, 0x86, 0x3A, 0xc6, 0x48, /* green */
 128                 0x68, 0x54, 0x88, 0xC6, 0xc8, 0xB8, /* magenta */
 129                 0x6A, 0x41, 0x8A, 0xD4, 0xcA, 0x64, /* red */
 130                 0x6C, 0x23, 0x8C, 0x72, 0xcC, 0xD4, /* blue */
 131                 0x6E, 0x10, 0x8E, 0x80, 0xcE, 0x80, /* black */
 132         };
 133         struct bt866 *encoder = to_bt866(sd);
 134         u8 val;
 135         int i;
 136
 137         for (i = 0; i < ARRAY_SIZE(init) / 2; i += 2)
 138                 bt866_write(encoder, init[i], init[i+1]);
 139
 140         val = encoder->reg[0xdc];
 141
 142         if (input == 0)
 143                 val |= 0x40; /* CBSWAP */
 144         else
 145                 val &= ~0x40; /* !CBSWAP */
 146
 147         bt866_write(encoder, 0xdc, val);
 148
 149         val = encoder->reg[0xcc];
 150         if (input == 2)
 151                 val |= 0x01; /* OSDBAR */
 152         else
 153                 val &= ~0x01; /* !OSDBAR */
 154         bt866_write(encoder, 0xcc, val);
 155
 156         v4l2_dbg(1, debug, sd, "set input %d\n", input);
 157
 158         switch (input) {
 159         case 0:
 160         case 1:
 161         case 2:
 162                 break;
 163         default:
 164                 return -EINVAL;
 165         }
 166         return 0;
 167 }
 168
 169
 170 static int bt866_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
 171 {
 172         struct i2c_client *client = v4l2_get_subdevdata(sd);
 173
 174         return v4l2_chip_ident_i2c_client(client, chip, V4L2_IDENT_BT866, 0);
 175 }
 176
 177 /* ----------------------------------------------------------------------- */
 178
 179 static const struct v4l2_subdev_core_ops bt866_core_ops = {
 180         .g_chip_ident = bt866_g_chip_ident,
 181 };
 182
 183 static const struct v4l2_subdev_video_ops bt866_video_ops = {
 184         .s_std_output = bt866_s_std_output,
 185         .s_routing = bt866_s_routing,
 186 };
 187
 188 static const struct v4l2_subdev_ops bt866_ops = {
 189         .core = &bt866_core_ops,
 190         .video = &bt866_video_ops,
 191 };
 192
 193 static int bt866_probe(struct i2c_client *client,
 194                         const struct i2c_device_id *id)
 195 {
 196         struct bt866 *encoder;
 197         struct v4l2_subdev *sd;
 198
 199         v4l_info(client, "chip found @ 0x%x (%s)\n",
 200                         client->addr << 1, client->adapter->name);
 201
 202         encoder = kzalloc(sizeof(*encoder), GFP_KERNEL);
 203         if (encoder == NULL)
 204                 return -ENOMEM;
 205         sd = &encoder->sd;
 206         v4l2_i2c_subdev_init(sd, client, &bt866_ops);
 207         return 0;
 208 }
 209
 210 static int bt866_remove(struct i2c_client *client)
 211 {
 212         struct v4l2_subdev *sd = i2c_get_clientdata(client);
 213
 214         v4l2_device_unregister_subdev(sd);
 215         kfree(to_bt866(sd));
 216         return 0;
 217 }
 218
 219 static const struct i2c_device_id bt866_id[] = {
 220         { "bt866", 0 },
 221         { }
 222 };
 223 MODULE_DEVICE_TABLE(i2c, bt866_id);
 224
 225 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
 226         .name = "bt866",
 227         .probe = bt866_probe,
 228         .remove = bt866_remove,
 229         .id_table = bt866_id,
 230 };