drivers/media/video/cs53l32a.c

   1 /*
   2  * cs53l32a (Adaptec AVC-2010 and AVC-2410) i2c ivtv driver.
   3  * Copyright (C) 2005  Martin Vaughan
   4  *
   5  * Audio source switching for Adaptec AVC-2410 added by Trev Jackson
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22
  23 #include <linux/module.h>
  24 #include <linux/types.h>
  25 #include <linux/slab.h>
  26 #include <linux/ioctl.h>
  27 #include <asm/uaccess.h>
  28 #include <linux/i2c.h>
  29 #include <linux/videodev2.h>
  30 #include <media/v4l2-device.h>
  31 #include <media/v4l2-chip-ident.h>
  32 #include <media/v4l2-ctrls.h>
  33 #include <media/v4l2-i2c-drv.h>
  34
  35 MODULE_DESCRIPTION("i2c device driver for cs53l32a Audio ADC");
  36 MODULE_AUTHOR("Martin Vaughan");
  37 MODULE_LICENSE("GPL");
  38
  39 static int debug;
  40
  41 module_param(debug, bool, 0644);
  42
  43 MODULE_PARM_DESC(debug, "Debugging messages, 0=Off (default), 1=On");
  44
  45
  46 struct cs53l32a_state {
  47         struct v4l2_subdev sd;
  48         struct v4l2_ctrl_handler hdl;
  49 };
  50
  51 static inline struct cs53l32a_state *to_state(struct v4l2_subdev *sd)
  52 {
  53         return container_of(sd, struct cs53l32a_state, sd);
  54 }
  55
  56 static inline struct v4l2_subdev *to_sd(struct v4l2_ctrl *ctrl)
  57 {
  58         return &container_of(ctrl->handler, struct cs53l32a_state, hdl)->sd;
  59 }
  60
  61 /* ----------------------------------------------------------------------- */
  62
  63 static int cs53l32a_write(struct v4l2_subdev *sd, u8 reg, u8 value)
  64 {
  65         struct i2c_client *client = v4l2_get_subdevdata(sd);
  66
  67         return i2c_smbus_write_byte_data(client, reg, value);
  68 }
  69
  70 static int cs53l32a_read(struct v4l2_subdev *sd, u8 reg)
  71 {
  72         struct i2c_client *client = v4l2_get_subdevdata(sd);
  73
  74         return i2c_smbus_read_byte_data(client, reg);
  75 }
  76
  77 static int cs53l32a_s_routing(struct v4l2_subdev *sd,
  78                               u32 input, u32 output, u32 config)
  79 {
  80         /* There are 2 physical inputs, but the second input can be
  81            placed in two modes, the first mode bypasses the PGA (gain),
  82            the second goes through the PGA. Hence there are three
  83            possible inputs to choose from. */
  84         if (input > 2) {
  85                 v4l2_err(sd, "Invalid input %d.\n", input);
  86                 return -EINVAL;
  87         }
  88         cs53l32a_write(sd, 0x01, 0x01 + (input << 4));
  89         return 0;
  90 }
  91
  92 static int cs53l32a_s_ctrl(struct v4l2_ctrl *ctrl)
  93 {
  94         struct v4l2_subdev *sd = to_sd(ctrl);
  95
  96         switch (ctrl->id) {
  97         case V4L2_CID_AUDIO_MUTE:
  98                 cs53l32a_write(sd, 0x03, ctrl->val ? 0xf0 : 0x30);
  99                 return 0;
 100         case V4L2_CID_AUDIO_VOLUME:
 101                 cs53l32a_write(sd, 0x04, (u8)ctrl->val);
 102                 cs53l32a_write(sd, 0x05, (u8)ctrl->val);
 103                 return 0;
 104         }
 105         return -EINVAL;
 106 }
 107
 108 static int cs53l32a_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
 109 {
 110         struct i2c_client *client = v4l2_get_subdevdata(sd);
 111
 112         return v4l2_chip_ident_i2c_client(client,
 113                         chip, V4L2_IDENT_CS53l32A, 0);
 114 }
 115
 116 static int cs53l32a_log_status(struct v4l2_subdev *sd)
 117 {
 118         struct cs53l32a_state *state = to_state(sd);
 119         u8 v = cs53l32a_read(sd, 0x01);
 120
 121         v4l2_info(sd, "Input:  %d\n", (v >> 4) & 3);
 122         v4l2_ctrl_handler_log_status(&state->hdl, sd->name);
 123         return 0;
 124 }
 125
 126 /* ----------------------------------------------------------------------- */
 127
 128 static const struct v4l2_ctrl_ops cs53l32a_ctrl_ops = {
 129         .s_ctrl = cs53l32a_s_ctrl,
 130 };
 131
 132 static const struct v4l2_subdev_core_ops cs53l32a_core_ops = {
 133         .log_status = cs53l32a_log_status,
 134         .g_chip_ident = cs53l32a_g_chip_ident,
 135         .g_ext_ctrls = v4l2_subdev_g_ext_ctrls,
 136         .try_ext_ctrls = v4l2_subdev_try_ext_ctrls,
 137         .s_ext_ctrls = v4l2_subdev_s_ext_ctrls,
 138         .g_ctrl = v4l2_subdev_g_ctrl,
 139         .s_ctrl = v4l2_subdev_s_ctrl,
 140         .queryctrl = v4l2_subdev_queryctrl,
 141         .querymenu = v4l2_subdev_querymenu,
 142 };
 143
 144 static const struct v4l2_subdev_audio_ops cs53l32a_audio_ops = {
 145         .s_routing = cs53l32a_s_routing,
 146 };
 147
 148 static const struct v4l2_subdev_ops cs53l32a_ops = {
 149         .core = &cs53l32a_core_ops,
 150         .audio = &cs53l32a_audio_ops,
 151 };
 152
 153 /* ----------------------------------------------------------------------- */
 154
 155 /* i2c implementation */
 156
 157 /*
 158  * Generic i2c probe
 159  * concerning the addresses: i2c wants 7 bit (without the r/w bit), so '>>1'
 160  */
 161
 162 static int cs53l32a_probe(struct i2c_client *client,
 163                           const struct i2c_device_id *id)
 164 {
 165         struct cs53l32a_state *state;
 166         struct v4l2_subdev *sd;
 167         int i;
 168
 169         /* Check if the adapter supports the needed features */
 170         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 171                 return -EIO;
 172
 173         if (!id)
 174                 strlcpy(client->name, "cs53l32a", sizeof(client->name));
 175
 176         v4l_info(client, "chip found @ 0x%x (%s)\n",
 177                         client->addr << 1, client->adapter->name);
 178
 179         state = kzalloc(sizeof(struct cs53l32a_state), GFP_KERNEL);
 180         if (state == NULL)
 181                 return -ENOMEM;
 182         sd = &state->sd;
 183         v4l2_i2c_subdev_init(sd, client, &cs53l32a_ops);
 184
 185         for (i = 1; i <= 7; i++) {
 186                 u8 v = cs53l32a_read(sd, i);
 187
 188                 v4l2_dbg(1, debug, sd, "Read Reg %d %02x\n", i, v);
 189         }
 190
 191         v4l2_ctrl_handler_init(&state->hdl, 2);
 192         v4l2_ctrl_new_std(&state->hdl, &cs53l32a_ctrl_ops,
 193                         V4L2_CID_AUDIO_VOLUME, -96, 12, 1, 0);
 194         v4l2_ctrl_new_std(&state->hdl, &cs53l32a_ctrl_ops,
 195                         V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0);
 196         sd->ctrl_handler = &state->hdl;
 197         if (state->hdl.error) {
 198                 int err = state->hdl.error;
 199
 200                 v4l2_ctrl_handler_free(&state->hdl);
 201                 kfree(state);
 202                 return err;
 203         }
 204
 205         /* Set cs53l32a internal register for Adaptec 2010/2410 setup */
 206
 207         cs53l32a_write(sd, 0x01, 0x21);
 208         cs53l32a_write(sd, 0x02, 0x29);
 209         cs53l32a_write(sd, 0x03, 0x30);
 210         cs53l32a_write(sd, 0x04, 0x00);
 211         cs53l32a_write(sd, 0x05, 0x00);
 212         cs53l32a_write(sd, 0x06, 0x00);
 213         cs53l32a_write(sd, 0x07, 0x00);
 214
 215         /* Display results, should be 0x21,0x29,0x30,0x00,0x00,0x00,0x00 */
 216
 217         for (i = 1; i <= 7; i++) {
 218                 u8 v = cs53l32a_read(sd, i);
 219
 220                 v4l2_dbg(1, debug, sd, "Read Reg %d %02x\n", i, v);
 221         }
 222         return 0;
 223 }
 224
 225 static int cs53l32a_remove(struct i2c_client *client)
 226 {
 227         struct v4l2_subdev *sd = i2c_get_clientdata(client);
 228         struct cs53l32a_state *state = to_state(sd);
 229
 230         v4l2_device_unregister_subdev(sd);
 231         v4l2_ctrl_handler_free(&state->hdl);
 232         kfree(state);
 233         return 0;
 234 }
 235
 236 static const struct i2c_device_id cs53l32a_id[] = {
 237         { "cs53l32a", 0 },
 238         { }
 239 };
 240 MODULE_DEVICE_TABLE(i2c, cs53l32a_id);
 241
 242 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
 243         .name = "cs53l32a",
 244         .remove = cs53l32a_remove,
 245         .probe = cs53l32a_probe,
 246         .id_table = cs53l32a_id,
 247 };