1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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
33MODULE_DESCRIPTION("i2c device driver for cs53l32a Audio ADC");
34MODULE_AUTHOR("Martin Vaughan");
35MODULE_LICENSE("GPL");
36
37static bool debug;
38
39module_param(debug, bool, 0644);
40
41MODULE_PARM_DESC(debug, "Debugging messages, 0=Off (default), 1=On");
42
43
44struct cs53l32a_state {
45 struct v4l2_subdev sd;
46 struct v4l2_ctrl_handler hdl;
47};
48
49static inline struct cs53l32a_state *to_state(struct v4l2_subdev *sd)
50{
51 return container_of(sd, struct cs53l32a_state, sd);
52}
53
54static 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
61static 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
68static 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
75static int cs53l32a_s_routing(struct v4l2_subdev *sd,
76 u32 input, u32 output, u32 config)
77{
78
79
80
81
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
90static 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
106static 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
118static const struct v4l2_ctrl_ops cs53l32a_ctrl_ops = {
119 .s_ctrl = cs53l32a_s_ctrl,
120};
121
122static 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
133static const struct v4l2_subdev_audio_ops cs53l32a_audio_ops = {
134 .s_routing = cs53l32a_s_routing,
135};
136
137static const struct v4l2_subdev_ops cs53l32a_ops = {
138 .core = &cs53l32a_core_ops,
139 .audio = &cs53l32a_audio_ops,
140};
141
142
143
144
145
146
147
148
149
150
151static 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
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
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
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
213static 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
223static const struct i2c_device_id cs53l32a_id[] = {
224 { "cs53l32a", 0 },
225 { }
226};
227MODULE_DEVICE_TABLE(i2c, cs53l32a_id);
228
229static 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
239module_i2c_driver(cs53l32a_driver);
240