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 #if 0
 170 /* Code to setup square pixels, might be of some use in the future,
 171    but is currently unused. */
 172         val = encoder->reg[0xdc];
 173         if (*iarg)
 174                 val |= 1; /* SQUARE */
 175         else
 176                 val &= ~1; /* !SQUARE */
 177         bt866_write(client, 0xdc, val);
 178 #endif
 179
 180 static int bt866_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
 181 {
 182         struct i2c_client *client = v4l2_get_subdevdata(sd);
 183
 184         return v4l2_chip_ident_i2c_client(client, chip, V4L2_IDENT_BT866, 0);
 185 }
 186
 187 /* ----------------------------------------------------------------------- */
 188
 189 static const struct v4l2_subdev_core_ops bt866_core_ops = {
 190         .g_chip_ident = bt866_g_chip_ident,
 191 };
 192
 193 static const struct v4l2_subdev_video_ops bt866_video_ops = {
 194         .s_std_output = bt866_s_std_output,
 195         .s_routing = bt866_s_routing,
 196 };
 197
 198 static const struct v4l2_subdev_ops bt866_ops = {
 199         .core = &bt866_core_ops,
 200         .video = &bt866_video_ops,
 201 };
 202
 203 static int bt866_probe(struct i2c_client *client,
 204                         const struct i2c_device_id *id)
 205 {
 206         struct bt866 *encoder;
 207         struct v4l2_subdev *sd;
 208
 209         v4l_info(client, "chip found @ 0x%x (%s)\n",
 210                         client->addr << 1, client->adapter->name);
 211
 212         encoder = kzalloc(sizeof(*encoder), GFP_KERNEL);
 213         if (encoder == NULL)
 214                 return -ENOMEM;
 215         sd = &encoder->sd;
 216         v4l2_i2c_subdev_init(sd, client, &bt866_ops);
 217         return 0;
 218 }
 219
 220 static int bt866_remove(struct i2c_client *client)
 221 {
 222         struct v4l2_subdev *sd = i2c_get_clientdata(client);
 223
 224         v4l2_device_unregister_subdev(sd);
 225         kfree(to_bt866(sd));
 226         return 0;
 227 }
 228
 229 static const struct i2c_device_id bt866_id[] = {
 230         { "bt866", 0 },
 231         { }
 232 };
 233 MODULE_DEVICE_TABLE(i2c, bt866_id);
 234
 235 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
 236         .name = "bt866",
 237         .probe = bt866_probe,
 238         .remove = bt866_remove,
 239         .id_table = bt866_id,
 240 };