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 .g_ext_ctrls = v4l2_subdev_g_ext_ctrls, 125 .try_ext_ctrls = v4l2_subdev_try_ext_ctrls, 126 .s_ext_ctrls = v4l2_subdev_s_ext_ctrls, 127 .g_ctrl = v4l2_subdev_g_ctrl, 128 .s_ctrl = v4l2_subdev_s_ctrl, 129 .queryctrl = v4l2_subdev_queryctrl, 130 .querymenu = v4l2_subdev_querymenu, 131 }; 132 133 static const struct v4l2_subdev_audio_ops cs53l32a_audio_ops = { 134 .s_routing = cs53l32a_s_routing, 135 }; 136 137 static const struct v4l2_subdev_ops cs53l32a_ops = { 138 .core = &cs53l32a_core_ops, 139 .audio = &cs53l32a_audio_ops, 140 }; 141 142 /* ----------------------------------------------------------------------- */ 143 144 /* i2c implementation */ 145 146 /* 147 * Generic i2c probe 148 * concerning the addresses: i2c wants 7 bit (without the r/w bit), so '>>1' 149 */ 150 151 static int cs53l32a_probe(struct i2c_client *client, 152 const struct i2c_device_id *id) 153 { 154 struct cs53l32a_state *state; 155 struct v4l2_subdev *sd; 156 int i; 157 158 /* Check if the adapter supports the needed features */ 159 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 160 return -EIO; 161 162 if (!id) 163 strlcpy(client->name, "cs53l32a", sizeof(client->name)); 164 165 v4l_info(client, "chip found @ 0x%x (%s)\n", 166 client->addr << 1, client->adapter->name); 167 168 state = devm_kzalloc(&client->dev, sizeof(*state), GFP_KERNEL); 169 if (state == NULL) 170 return -ENOMEM; 171 sd = &state->sd; 172 v4l2_i2c_subdev_init(sd, client, &cs53l32a_ops); 173 174 for (i = 1; i <= 7; i++) { 175 u8 v = cs53l32a_read(sd, i); 176 177 v4l2_dbg(1, debug, sd, "Read Reg %d %02x\n", i, v); 178 } 179 180 v4l2_ctrl_handler_init(&state->hdl, 2); 181 v4l2_ctrl_new_std(&state->hdl, &cs53l32a_ctrl_ops, 182 V4L2_CID_AUDIO_VOLUME, -96, 12, 1, 0); 183 v4l2_ctrl_new_std(&state->hdl, &cs53l32a_ctrl_ops, 184 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0); 185 sd->ctrl_handler = &state->hdl; 186 if (state->hdl.error) { 187 int err = state->hdl.error; 188 189 v4l2_ctrl_handler_free(&state->hdl); 190 return err; 191 } 192 193 /* Set cs53l32a internal register for Adaptec 2010/2410 setup */ 194 195 cs53l32a_write(sd, 0x01, 0x21); 196 cs53l32a_write(sd, 0x02, 0x29); 197 cs53l32a_write(sd, 0x03, 0x30); 198 cs53l32a_write(sd, 0x04, 0x00); 199 cs53l32a_write(sd, 0x05, 0x00); 200 cs53l32a_write(sd, 0x06, 0x00); 201 cs53l32a_write(sd, 0x07, 0x00); 202 203 /* Display results, should be 0x21,0x29,0x30,0x00,0x00,0x00,0x00 */ 204 205 for (i = 1; i <= 7; i++) { 206 u8 v = cs53l32a_read(sd, i); 207 208 v4l2_dbg(1, debug, sd, "Read Reg %d %02x\n", i, v); 209 } 210 return 0; 211 } 212 213 static int cs53l32a_remove(struct i2c_client *client) 214 { 215 struct v4l2_subdev *sd = i2c_get_clientdata(client); 216 struct cs53l32a_state *state = to_state(sd); 217 218 v4l2_device_unregister_subdev(sd); 219 v4l2_ctrl_handler_free(&state->hdl); 220 return 0; 221 } 222 223 static const struct i2c_device_id cs53l32a_id[] = { 224 { "cs53l32a", 0 }, 225 { } 226 }; 227 MODULE_DEVICE_TABLE(i2c, cs53l32a_id); 228 229 static struct i2c_driver cs53l32a_driver = { 230 .driver = { 231 .owner = THIS_MODULE, 232 .name = "cs53l32a", 233 }, 234 .probe = cs53l32a_probe, 235 .remove = cs53l32a_remove, 236 .id_table = cs53l32a_id, 237 }; 238 239 module_i2c_driver(cs53l32a_driver); 240