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