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};
125
126static const struct v4l2_subdev_audio_ops cs53l32a_audio_ops = {
127 .s_routing = cs53l32a_s_routing,
128};
129
130static const struct v4l2_subdev_ops cs53l32a_ops = {
131 .core = &cs53l32a_core_ops,
132 .audio = &cs53l32a_audio_ops,
133};
134
135
136
137
138
139
140
141
142
143
144static 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
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
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
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
206static 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
216static const struct i2c_device_id cs53l32a_id[] = {
217 { "cs53l32a", 0 },
218 { }
219};
220MODULE_DEVICE_TABLE(i2c, cs53l32a_id);
221
222static 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
231module_i2c_driver(cs53l32a_driver);
232