1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Generic i2c interface for ALSA |
4 | * |
5 | * (c) 1998 Gerd Knorr <kraxel@cs.tu-berlin.de> |
6 | * Modified for the ALSA driver by Jaroslav Kysela <perex@perex.cz> |
7 | */ |
8 | |
9 | #include <linux/init.h> |
10 | #include <linux/slab.h> |
11 | #include <linux/module.h> |
12 | #include <linux/string.h> |
13 | #include <linux/errno.h> |
14 | #include <sound/core.h> |
15 | #include <sound/i2c.h> |
16 | |
17 | MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>" ); |
18 | MODULE_DESCRIPTION("Generic i2c interface for ALSA" ); |
19 | MODULE_LICENSE("GPL" ); |
20 | |
21 | static int snd_i2c_bit_sendbytes(struct snd_i2c_device *device, |
22 | unsigned char *bytes, int count); |
23 | static int snd_i2c_bit_readbytes(struct snd_i2c_device *device, |
24 | unsigned char *bytes, int count); |
25 | static int snd_i2c_bit_probeaddr(struct snd_i2c_bus *bus, |
26 | unsigned short addr); |
27 | |
28 | static const struct snd_i2c_ops snd_i2c_bit_ops = { |
29 | .sendbytes = snd_i2c_bit_sendbytes, |
30 | .readbytes = snd_i2c_bit_readbytes, |
31 | .probeaddr = snd_i2c_bit_probeaddr, |
32 | }; |
33 | |
34 | static int snd_i2c_bus_free(struct snd_i2c_bus *bus) |
35 | { |
36 | struct snd_i2c_bus *slave; |
37 | struct snd_i2c_device *device; |
38 | |
39 | if (snd_BUG_ON(!bus)) |
40 | return -EINVAL; |
41 | while (!list_empty(head: &bus->devices)) { |
42 | device = snd_i2c_device(bus->devices.next); |
43 | snd_i2c_device_free(device); |
44 | } |
45 | if (bus->master) |
46 | list_del(entry: &bus->buses); |
47 | else { |
48 | while (!list_empty(head: &bus->buses)) { |
49 | slave = snd_i2c_slave_bus(bus->buses.next); |
50 | snd_device_free(card: bus->card, device_data: slave); |
51 | } |
52 | } |
53 | if (bus->private_free) |
54 | bus->private_free(bus); |
55 | kfree(objp: bus); |
56 | return 0; |
57 | } |
58 | |
59 | static int snd_i2c_bus_dev_free(struct snd_device *device) |
60 | { |
61 | struct snd_i2c_bus *bus = device->device_data; |
62 | return snd_i2c_bus_free(bus); |
63 | } |
64 | |
65 | int snd_i2c_bus_create(struct snd_card *card, const char *name, |
66 | struct snd_i2c_bus *master, struct snd_i2c_bus **ri2c) |
67 | { |
68 | struct snd_i2c_bus *bus; |
69 | int err; |
70 | static const struct snd_device_ops ops = { |
71 | .dev_free = snd_i2c_bus_dev_free, |
72 | }; |
73 | |
74 | *ri2c = NULL; |
75 | bus = kzalloc(size: sizeof(*bus), GFP_KERNEL); |
76 | if (bus == NULL) |
77 | return -ENOMEM; |
78 | mutex_init(&bus->lock_mutex); |
79 | INIT_LIST_HEAD(list: &bus->devices); |
80 | INIT_LIST_HEAD(list: &bus->buses); |
81 | bus->card = card; |
82 | bus->ops = &snd_i2c_bit_ops; |
83 | if (master) { |
84 | list_add_tail(new: &bus->buses, head: &master->buses); |
85 | bus->master = master; |
86 | } |
87 | strscpy(p: bus->name, q: name, size: sizeof(bus->name)); |
88 | err = snd_device_new(card, type: SNDRV_DEV_BUS, device_data: bus, ops: &ops); |
89 | if (err < 0) { |
90 | snd_i2c_bus_free(bus); |
91 | return err; |
92 | } |
93 | *ri2c = bus; |
94 | return 0; |
95 | } |
96 | |
97 | EXPORT_SYMBOL(snd_i2c_bus_create); |
98 | |
99 | int snd_i2c_device_create(struct snd_i2c_bus *bus, const char *name, |
100 | unsigned char addr, struct snd_i2c_device **rdevice) |
101 | { |
102 | struct snd_i2c_device *device; |
103 | |
104 | *rdevice = NULL; |
105 | if (snd_BUG_ON(!bus)) |
106 | return -EINVAL; |
107 | device = kzalloc(size: sizeof(*device), GFP_KERNEL); |
108 | if (device == NULL) |
109 | return -ENOMEM; |
110 | device->addr = addr; |
111 | strscpy(p: device->name, q: name, size: sizeof(device->name)); |
112 | list_add_tail(new: &device->list, head: &bus->devices); |
113 | device->bus = bus; |
114 | *rdevice = device; |
115 | return 0; |
116 | } |
117 | |
118 | EXPORT_SYMBOL(snd_i2c_device_create); |
119 | |
120 | int snd_i2c_device_free(struct snd_i2c_device *device) |
121 | { |
122 | if (device->bus) |
123 | list_del(entry: &device->list); |
124 | if (device->private_free) |
125 | device->private_free(device); |
126 | kfree(objp: device); |
127 | return 0; |
128 | } |
129 | |
130 | EXPORT_SYMBOL(snd_i2c_device_free); |
131 | |
132 | int snd_i2c_sendbytes(struct snd_i2c_device *device, unsigned char *bytes, int count) |
133 | { |
134 | return device->bus->ops->sendbytes(device, bytes, count); |
135 | } |
136 | |
137 | EXPORT_SYMBOL(snd_i2c_sendbytes); |
138 | |
139 | int snd_i2c_readbytes(struct snd_i2c_device *device, unsigned char *bytes, int count) |
140 | { |
141 | return device->bus->ops->readbytes(device, bytes, count); |
142 | } |
143 | |
144 | EXPORT_SYMBOL(snd_i2c_readbytes); |
145 | |
146 | int snd_i2c_probeaddr(struct snd_i2c_bus *bus, unsigned short addr) |
147 | { |
148 | return bus->ops->probeaddr(bus, addr); |
149 | } |
150 | |
151 | EXPORT_SYMBOL(snd_i2c_probeaddr); |
152 | |
153 | /* |
154 | * bit-operations |
155 | */ |
156 | |
157 | static inline void snd_i2c_bit_hw_start(struct snd_i2c_bus *bus) |
158 | { |
159 | if (bus->hw_ops.bit->start) |
160 | bus->hw_ops.bit->start(bus); |
161 | } |
162 | |
163 | static inline void snd_i2c_bit_hw_stop(struct snd_i2c_bus *bus) |
164 | { |
165 | if (bus->hw_ops.bit->stop) |
166 | bus->hw_ops.bit->stop(bus); |
167 | } |
168 | |
169 | static void snd_i2c_bit_direction(struct snd_i2c_bus *bus, int clock, int data) |
170 | { |
171 | if (bus->hw_ops.bit->direction) |
172 | bus->hw_ops.bit->direction(bus, clock, data); |
173 | } |
174 | |
175 | static void snd_i2c_bit_set(struct snd_i2c_bus *bus, int clock, int data) |
176 | { |
177 | bus->hw_ops.bit->setlines(bus, clock, data); |
178 | } |
179 | |
180 | #if 0 |
181 | static int snd_i2c_bit_clock(struct snd_i2c_bus *bus) |
182 | { |
183 | if (bus->hw_ops.bit->getclock) |
184 | return bus->hw_ops.bit->getclock(bus); |
185 | return -ENXIO; |
186 | } |
187 | #endif |
188 | |
189 | static int snd_i2c_bit_data(struct snd_i2c_bus *bus, int ack) |
190 | { |
191 | return bus->hw_ops.bit->getdata(bus, ack); |
192 | } |
193 | |
194 | static void snd_i2c_bit_start(struct snd_i2c_bus *bus) |
195 | { |
196 | snd_i2c_bit_hw_start(bus); |
197 | snd_i2c_bit_direction(bus, clock: 1, data: 1); /* SCL - wr, SDA - wr */ |
198 | snd_i2c_bit_set(bus, clock: 1, data: 1); |
199 | snd_i2c_bit_set(bus, clock: 1, data: 0); |
200 | snd_i2c_bit_set(bus, clock: 0, data: 0); |
201 | } |
202 | |
203 | static void snd_i2c_bit_stop(struct snd_i2c_bus *bus) |
204 | { |
205 | snd_i2c_bit_set(bus, clock: 0, data: 0); |
206 | snd_i2c_bit_set(bus, clock: 1, data: 0); |
207 | snd_i2c_bit_set(bus, clock: 1, data: 1); |
208 | snd_i2c_bit_hw_stop(bus); |
209 | } |
210 | |
211 | static void snd_i2c_bit_send(struct snd_i2c_bus *bus, int data) |
212 | { |
213 | snd_i2c_bit_set(bus, clock: 0, data); |
214 | snd_i2c_bit_set(bus, clock: 1, data); |
215 | snd_i2c_bit_set(bus, clock: 0, data); |
216 | } |
217 | |
218 | static int snd_i2c_bit_ack(struct snd_i2c_bus *bus) |
219 | { |
220 | int ack; |
221 | |
222 | snd_i2c_bit_set(bus, clock: 0, data: 1); |
223 | snd_i2c_bit_set(bus, clock: 1, data: 1); |
224 | snd_i2c_bit_direction(bus, clock: 1, data: 0); /* SCL - wr, SDA - rd */ |
225 | ack = snd_i2c_bit_data(bus, ack: 1); |
226 | snd_i2c_bit_direction(bus, clock: 1, data: 1); /* SCL - wr, SDA - wr */ |
227 | snd_i2c_bit_set(bus, clock: 0, data: 1); |
228 | return ack ? -EIO : 0; |
229 | } |
230 | |
231 | static int snd_i2c_bit_sendbyte(struct snd_i2c_bus *bus, unsigned char data) |
232 | { |
233 | int i, err; |
234 | |
235 | for (i = 7; i >= 0; i--) |
236 | snd_i2c_bit_send(bus, data: !!(data & (1 << i))); |
237 | err = snd_i2c_bit_ack(bus); |
238 | if (err < 0) |
239 | return err; |
240 | return 0; |
241 | } |
242 | |
243 | static int snd_i2c_bit_readbyte(struct snd_i2c_bus *bus, int last) |
244 | { |
245 | int i; |
246 | unsigned char data = 0; |
247 | |
248 | snd_i2c_bit_set(bus, clock: 0, data: 1); |
249 | snd_i2c_bit_direction(bus, clock: 1, data: 0); /* SCL - wr, SDA - rd */ |
250 | for (i = 7; i >= 0; i--) { |
251 | snd_i2c_bit_set(bus, clock: 1, data: 1); |
252 | if (snd_i2c_bit_data(bus, ack: 0)) |
253 | data |= (1 << i); |
254 | snd_i2c_bit_set(bus, clock: 0, data: 1); |
255 | } |
256 | snd_i2c_bit_direction(bus, clock: 1, data: 1); /* SCL - wr, SDA - wr */ |
257 | snd_i2c_bit_send(bus, data: !!last); |
258 | return data; |
259 | } |
260 | |
261 | static int snd_i2c_bit_sendbytes(struct snd_i2c_device *device, |
262 | unsigned char *bytes, int count) |
263 | { |
264 | struct snd_i2c_bus *bus = device->bus; |
265 | int err, res = 0; |
266 | |
267 | if (device->flags & SND_I2C_DEVICE_ADDRTEN) |
268 | return -EIO; /* not yet implemented */ |
269 | snd_i2c_bit_start(bus); |
270 | err = snd_i2c_bit_sendbyte(bus, data: device->addr << 1); |
271 | if (err < 0) { |
272 | snd_i2c_bit_hw_stop(bus); |
273 | return err; |
274 | } |
275 | while (count-- > 0) { |
276 | err = snd_i2c_bit_sendbyte(bus, data: *bytes++); |
277 | if (err < 0) { |
278 | snd_i2c_bit_hw_stop(bus); |
279 | return err; |
280 | } |
281 | res++; |
282 | } |
283 | snd_i2c_bit_stop(bus); |
284 | return res; |
285 | } |
286 | |
287 | static int snd_i2c_bit_readbytes(struct snd_i2c_device *device, |
288 | unsigned char *bytes, int count) |
289 | { |
290 | struct snd_i2c_bus *bus = device->bus; |
291 | int err, res = 0; |
292 | |
293 | if (device->flags & SND_I2C_DEVICE_ADDRTEN) |
294 | return -EIO; /* not yet implemented */ |
295 | snd_i2c_bit_start(bus); |
296 | err = snd_i2c_bit_sendbyte(bus, data: (device->addr << 1) | 1); |
297 | if (err < 0) { |
298 | snd_i2c_bit_hw_stop(bus); |
299 | return err; |
300 | } |
301 | while (count-- > 0) { |
302 | err = snd_i2c_bit_readbyte(bus, last: count == 0); |
303 | if (err < 0) { |
304 | snd_i2c_bit_hw_stop(bus); |
305 | return err; |
306 | } |
307 | *bytes++ = (unsigned char)err; |
308 | res++; |
309 | } |
310 | snd_i2c_bit_stop(bus); |
311 | return res; |
312 | } |
313 | |
314 | static int snd_i2c_bit_probeaddr(struct snd_i2c_bus *bus, unsigned short addr) |
315 | { |
316 | int err; |
317 | |
318 | if (addr & 0x8000) /* 10-bit address */ |
319 | return -EIO; /* not yet implemented */ |
320 | if (addr & 0x7f80) /* invalid address */ |
321 | return -EINVAL; |
322 | snd_i2c_bit_start(bus); |
323 | err = snd_i2c_bit_sendbyte(bus, data: addr << 1); |
324 | snd_i2c_bit_stop(bus); |
325 | return err; |
326 | } |
327 | |