drivers/media/i2c/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
  18
  19 #include <linux/module.h>
  20 #include <linux/types.h>
  21 #include <linux/slab.h>
  22 #include <linux/ioctl.h>
  23 #include <linux/uaccess.h>
  24 #include <linux/i2c.h>
  25 #include <linux/videodev2.h>
  26 #include <media/v4l2-device.h>
  27 #include <media/v4l2-ctrls.h>
  28
  29 MODULE_DESCRIPTION("i2c device driver for cs53l32a Audio ADC");
  30 MODULE_AUTHOR("Martin Vaughan");
  31 MODULE_LICENSE("GPL");
  32
  33 static bool debug;
  34
  35 module_param(debug, bool, 0644);
  36
  37 MODULE_PARM_DESC(debug, "Debugging messages, 0=Off (default), 1=On");
  38
  39
  40 struct cs53l32a_state {
  41         struct v4l2_subdev sd;
  42         struct v4l2_ctrl_handler hdl;
  43 };
  44
  45 static inline struct cs53l32a_state *to_state(struct v4l2_subdev *sd)
  46 {
  47         return container_of(sd, struct cs53l32a_state, sd);
  48 }
  49
  50 static inline struct v4l2_subdev *to_sd(struct v4l2_ctrl *ctrl)
  51 {
  52         return &container_of(ctrl->handler, struct cs53l32a_state, hdl)->sd;
  53 }
  54
  55 /* ----------------------------------------------------------------------- */
  56
  57 static int cs53l32a_write(struct v4l2_subdev *sd, u8 reg, u8 value)
  58 {
  59         struct i2c_client *client = v4l2_get_subdevdata(sd);
  60
  61         return i2c_smbus_write_byte_data(client, reg, value);
  62 }
  63
  64 static int cs53l32a_read(struct v4l2_subdev *sd, u8 reg)
  65 {
  66         struct i2c_client *client = v4l2_get_subdevdata(sd);
  67
  68         return i2c_smbus_read_byte_data(client, reg);
  69 }
  70
  71 static int cs53l32a_s_routing(struct v4l2_subdev *sd,
  72                               u32 input, u32 output, u32 config)
  73 {
  74         /* There are 2 physical inputs, but the second input can be
  75            placed in two modes, the first mode bypasses the PGA (gain),
  76            the second goes through the PGA. Hence there are three
  77            possible inputs to choose from. */
  78         if (input > 2) {
  79                 v4l2_err(sd, "Invalid input %d.\n", input);
  80                 return -EINVAL;
  81         }
  82         cs53l32a_write(sd, 0x01, 0x01 + (input << 4));
  83         return 0;
  84 }
  85
  86 static int cs53l32a_s_ctrl(struct v4l2_ctrl *ctrl)
  87 {
  88         struct v4l2_subdev *sd = to_sd(ctrl);
  89
  90         switch (ctrl->id) {
  91         case V4L2_CID_AUDIO_MUTE:
  92                 cs53l32a_write(sd, 0x03, ctrl->val ? 0xf0 : 0x30);
  93                 return 0;
  94         case V4L2_CID_AUDIO_VOLUME:
  95                 cs53l32a_write(sd, 0x04, (u8)ctrl->val);
  96                 cs53l32a_write(sd, 0x05, (u8)ctrl->val);
  97                 return 0;
  98         }
  99         return -EINVAL;
 100 }
 101
 102 static int cs53l32a_log_status(struct v4l2_subdev *sd)
 103 {
 104         struct cs53l32a_state *state = to_state(sd);
 105         u8 v = cs53l32a_read(sd, 0x01);
 106
 107         v4l2_info(sd, "Input:  %d\n", (v >> 4) & 3);
 108         v4l2_ctrl_handler_log_status(&state->hdl, sd->name);
 109         return 0;
 110 }
 111
 112 /* ----------------------------------------------------------------------- */
 113
 114 static const struct v4l2_ctrl_ops cs53l32a_ctrl_ops = {
 115         .s_ctrl = cs53l32a_s_ctrl,
 116 };
 117
 118 static const struct v4l2_subdev_core_ops cs53l32a_core_ops = {
 119         .log_status = cs53l32a_log_status,
 120 };
 121
 122 static const struct v4l2_subdev_audio_ops cs53l32a_audio_ops = {
 123         .s_routing = cs53l32a_s_routing,
 124 };
 125
 126 static const struct v4l2_subdev_ops cs53l32a_ops = {
 127         .core = &cs53l32a_core_ops,
 128         .audio = &cs53l32a_audio_ops,
 129 };
 130
 131 /* ----------------------------------------------------------------------- */
 132
 133 /* i2c implementation */
 134
 135 /*
 136  * Generic i2c probe
 137  * concerning the addresses: i2c wants 7 bit (without the r/w bit), so '>>1'
 138  */
 139
 140 static int cs53l32a_probe(struct i2c_client *client,
 141                           const struct i2c_device_id *id)
 142 {
 143         struct cs53l32a_state *state;
 144         struct v4l2_subdev *sd;
 145         int i;
 146
 147         /* Check if the adapter supports the needed features */
 148         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 149                 return -EIO;
 150
 151         if (!id)
 152                 strlcpy(client->name, "cs53l32a", sizeof(client->name));
 153
 154         v4l_info(client, "chip found @ 0x%x (%s)\n",
 155                         client->addr << 1, client->adapter->name);
 156
 157         state = devm_kzalloc(&client->dev, sizeof(*state), GFP_KERNEL);
 158         if (state == NULL)
 159                 return -ENOMEM;
 160         sd = &state->sd;
 161         v4l2_i2c_subdev_init(sd, client, &cs53l32a_ops);
 162
 163         for (i = 1; i <= 7; i++) {
 164                 u8 v = cs53l32a_read(sd, i);
 165
 166                 v4l2_dbg(1, debug, sd, "Read Reg %d %02x\n", i, v);
 167         }
 168
 169         v4l2_ctrl_handler_init(&state->hdl, 2);
 170         v4l2_ctrl_new_std(&state->hdl, &cs53l32a_ctrl_ops,
 171                         V4L2_CID_AUDIO_VOLUME, -96, 12, 1, 0);
 172         v4l2_ctrl_new_std(&state->hdl, &cs53l32a_ctrl_ops,
 173                         V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0);
 174         sd->ctrl_handler = &state->hdl;
 175         if (state->hdl.error) {
 176                 int err = state->hdl.error;
 177
 178                 v4l2_ctrl_handler_free(&state->hdl);
 179                 return err;
 180         }
 181
 182         /* Set cs53l32a internal register for Adaptec 2010/2410 setup */
 183
 184         cs53l32a_write(sd, 0x01, 0x21);
 185         cs53l32a_write(sd, 0x02, 0x29);
 186         cs53l32a_write(sd, 0x03, 0x30);
 187         cs53l32a_write(sd, 0x04, 0x00);
 188         cs53l32a_write(sd, 0x05, 0x00);
 189         cs53l32a_write(sd, 0x06, 0x00);
 190         cs53l32a_write(sd, 0x07, 0x00);
 191
 192         /* Display results, should be 0x21,0x29,0x30,0x00,0x00,0x00,0x00 */
 193
 194         for (i = 1; i <= 7; i++) {
 195                 u8 v = cs53l32a_read(sd, i);
 196
 197                 v4l2_dbg(1, debug, sd, "Read Reg %d %02x\n", i, v);
 198         }
 199         return 0;
 200 }
 201
 202 static int cs53l32a_remove(struct i2c_client *client)
 203 {
 204         struct v4l2_subdev *sd = i2c_get_clientdata(client);
 205         struct cs53l32a_state *state = to_state(sd);
 206
 207         v4l2_device_unregister_subdev(sd);
 208         v4l2_ctrl_handler_free(&state->hdl);
 209         return 0;
 210 }
 211
 212 static const struct i2c_device_id cs53l32a_id[] = {
 213         { "cs53l32a", 0 },
 214         { }
 215 };
 216 MODULE_DEVICE_TABLE(i2c, cs53l32a_id);
 217
 218 static struct i2c_driver cs53l32a_driver = {
 219         .driver = {
 220                 .name   = "cs53l32a",
 221         },
 222         .probe          = cs53l32a_probe,
 223         .remove         = cs53l32a_remove,
 224         .id_table       = cs53l32a_id,
 225 };
 226
 227 module_i2c_driver(cs53l32a_driver);