xref: /freebsd/sys/dev/iicbus/iiconf.c (revision 1e413cf93298b5b97441a21d9a50fdcd0ee9945e)
1 /*-
2  * Copyright (c) 1998 Nicolas Souchu
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  */
26 
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
29 
30 #include <sys/param.h>
31 #include <sys/systm.h>
32 #include <sys/malloc.h>
33 #include <sys/module.h>
34 #include <sys/bus.h>
35 
36 #include <dev/iicbus/iiconf.h>
37 #include <dev/iicbus/iicbus.h>
38 #include "iicbus_if.h"
39 
40 /*
41  * iicbus_intr()
42  */
43 void
44 iicbus_intr(device_t bus, int event, char *buf)
45 {
46 	struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
47 
48 	/* call owner's intr routine */
49 	if (sc->owner)
50 		IICBUS_INTR(sc->owner, event, buf);
51 
52 	return;
53 }
54 
55 static int
56 iicbus_poll(struct iicbus_softc *sc, int how)
57 {
58 	int error;
59 
60 	switch (how) {
61 	case (IIC_WAIT | IIC_INTR):
62 		error = tsleep(sc, IICPRI|PCATCH, "iicreq", 0);
63 		break;
64 
65 	case (IIC_WAIT | IIC_NOINTR):
66 		error = tsleep(sc, IICPRI, "iicreq", 0);
67 		break;
68 
69 	default:
70 		return (EWOULDBLOCK);
71 		break;
72 	}
73 
74 	return (error);
75 }
76 
77 /*
78  * iicbus_request_bus()
79  *
80  * Allocate the device to perform transfers.
81  *
82  * how	: IIC_WAIT or IIC_DONTWAIT
83  */
84 int
85 iicbus_request_bus(device_t bus, device_t dev, int how)
86 {
87 	struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
88 	int s, error = 0;
89 
90 	/* first, ask the underlying layers if the request is ok */
91 	do {
92 		error = IICBUS_CALLBACK(device_get_parent(bus),
93 						IIC_REQUEST_BUS, (caddr_t)&how);
94 		if (error)
95 			error = iicbus_poll(sc, how);
96 	} while (error == EWOULDBLOCK);
97 
98 	while (!error) {
99 		s = splhigh();
100 		if (sc->owner && sc->owner != dev) {
101 			splx(s);
102 
103 			error = iicbus_poll(sc, how);
104 		} else {
105 			sc->owner = dev;
106 
107 			splx(s);
108 			return (0);
109 		}
110 
111 		/* free any allocated resource */
112 		if (error)
113 			IICBUS_CALLBACK(device_get_parent(bus), IIC_RELEASE_BUS,
114 					(caddr_t)&how);
115 	}
116 
117 	return (error);
118 }
119 
120 /*
121  * iicbus_release_bus()
122  *
123  * Release the device allocated with iicbus_request_dev()
124  */
125 int
126 iicbus_release_bus(device_t bus, device_t dev)
127 {
128 	struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
129 	int s, error;
130 
131 	/* first, ask the underlying layers if the release is ok */
132 	error = IICBUS_CALLBACK(device_get_parent(bus), IIC_RELEASE_BUS, NULL);
133 
134 	if (error)
135 		return (error);
136 
137 	s = splhigh();
138 	if (sc->owner != dev) {
139 		splx(s);
140 		return (EACCES);
141 	}
142 
143 	sc->owner = 0;
144 	splx(s);
145 
146 	/* wakeup waiting processes */
147 	wakeup(sc);
148 
149 	return (0);
150 }
151 
152 /*
153  * iicbus_started()
154  *
155  * Test if the iicbus is started by the controller
156  */
157 int
158 iicbus_started(device_t bus)
159 {
160 	struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
161 
162 	return (sc->started);
163 }
164 
165 /*
166  * iicbus_start()
167  *
168  * Send start condition to the slave addressed by 'slave'
169  */
170 int
171 iicbus_start(device_t bus, u_char slave, int timeout)
172 {
173 	struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
174 	int error = 0;
175 
176 	if (sc->started)
177 		return (EINVAL);		/* bus already started */
178 
179 	if (!(error = IICBUS_START(device_get_parent(bus), slave, timeout)))
180 		sc->started = slave;
181 	else
182 		sc->started = 0;
183 
184 	return (error);
185 }
186 
187 /*
188  * iicbus_repeated_start()
189  *
190  * Send start condition to the slave addressed by 'slave'
191  */
192 int
193 iicbus_repeated_start(device_t bus, u_char slave, int timeout)
194 {
195 	struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
196 	int error = 0;
197 
198 	if (!sc->started)
199 		return (EINVAL);     /* bus should have been already started */
200 
201 	if (!(error = IICBUS_REPEATED_START(device_get_parent(bus), slave, timeout)))
202 		sc->started = slave;
203 	else
204 		sc->started = 0;
205 
206 	return (error);
207 }
208 
209 /*
210  * iicbus_stop()
211  *
212  * Send stop condition to the bus
213  */
214 int
215 iicbus_stop(device_t bus)
216 {
217 	struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
218 	int error = 0;
219 
220 	if (!sc->started)
221 		return (EINVAL);		/* bus not started */
222 
223 	error = IICBUS_STOP(device_get_parent(bus));
224 
225 	/* refuse any further access */
226 	sc->started = 0;
227 
228 	return (error);
229 }
230 
231 /*
232  * iicbus_write()
233  *
234  * Write a block of data to the slave previously started by
235  * iicbus_start() call
236  */
237 int
238 iicbus_write(device_t bus, const char *buf, int len, int *sent, int timeout)
239 {
240 	struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
241 
242 	/* a slave must have been started with the appropriate address */
243 	if (!sc->started || (sc->started & LSB))
244 		return (EINVAL);
245 
246 	return (IICBUS_WRITE(device_get_parent(bus), buf, len, sent, timeout));
247 }
248 
249 /*
250  * iicbus_read()
251  *
252  * Read a block of data from the slave previously started by
253  * iicbus_read() call
254  */
255 int
256 iicbus_read(device_t bus, char *buf, int len, int *read, int last, int delay)
257 {
258 	struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
259 
260 	/* a slave must have been started with the appropriate address */
261 	if (!sc->started || !(sc->started & LSB))
262 		return (EINVAL);
263 
264 	return (IICBUS_READ(device_get_parent(bus), buf, len, read, last, delay));
265 }
266 
267 /*
268  * iicbus_write_byte()
269  *
270  * Write a byte to the slave previously started by iicbus_start() call
271  */
272 int
273 iicbus_write_byte(device_t bus, char byte, int timeout)
274 {
275 	char data = byte;
276 	int sent;
277 
278 	return (iicbus_write(bus, &data, 1, &sent, timeout));
279 }
280 
281 /*
282  * iicbus_read_byte()
283  *
284  * Read a byte from the slave previously started by iicbus_start() call
285  */
286 int
287 iicbus_read_byte(device_t bus, char *byte, int timeout)
288 {
289 	int read;
290 
291 	return (iicbus_read(bus, byte, 1, &read, IIC_LAST_READ, timeout));
292 }
293 
294 /*
295  * iicbus_block_write()
296  *
297  * Write a block of data to slave ; start/stop protocol managed
298  */
299 int
300 iicbus_block_write(device_t bus, u_char slave, char *buf, int len, int *sent)
301 {
302 	u_char addr = slave & ~LSB;
303 	int error;
304 
305 	if ((error = iicbus_start(bus, addr, 0)))
306 		return (error);
307 
308 	error = iicbus_write(bus, buf, len, sent, 0);
309 
310 	iicbus_stop(bus);
311 
312 	return (error);
313 }
314 
315 /*
316  * iicbus_block_read()
317  *
318  * Read a block of data from slave ; start/stop protocol managed
319  */
320 int
321 iicbus_block_read(device_t bus, u_char slave, char *buf, int len, int *read)
322 {
323 	u_char addr = slave | LSB;
324 	int error;
325 
326 	if ((error = iicbus_start(bus, addr, 0)))
327 		return (error);
328 
329 	error = iicbus_read(bus, buf, len, read, IIC_LAST_READ, 0);
330 
331 	iicbus_stop(bus);
332 
333 	return (error);
334 }
335 
336 /*
337  * iicbus_trasnfer()
338  *
339  * Do an aribtrary number of transfers on the iicbus.  We pass these
340  * raw requests to the bridge driver.  If the bridge driver supports
341  * them directly, then it manages all the details.  If not, it can use
342  * the helper function iicbus_transfer_gen() which will do the
343  * transfers at a low level.
344  *
345  * Pointers passed in as part of iic_msg must be kernel pointers.
346  * Callers that have user addresses to manage must do so on their own.
347  */
348 int
349 iicbus_transfer(device_t bus, struct iic_msg *msgs, uint32_t nmsgs)
350 {
351 	return (IICBUS_TRANSFER(device_get_parent(bus), msgs, nmsgs));
352 }
353 
354 /*
355  * Generic version of iicbus_transfer that calls the appropriate
356  * routines to accomplish this.  See note above about acceptable
357  * buffer addresses.
358  */
359 int
360 iicbus_transfer_gen(device_t dev, struct iic_msg *msgs, uint32_t nmsgs)
361 {
362 	int i, error, lenread, lenwrote, nkid;
363 	device_t *children, bus;
364 
365 	device_get_children(dev, &children, &nkid);
366 	if (nkid != 1)
367 		return EIO;
368 	bus = children[0];
369 	free(children, M_TEMP);
370 	for (i = 0, error = 0; i < nmsgs && error == 0; i++) {
371 		if (msgs[i].flags & IIC_M_RD)
372 			error = iicbus_block_read(bus, msgs[i].slave,
373 			    msgs[i].buf, msgs[i].len, &lenread);
374 		else
375 			error = iicbus_block_write(bus, msgs[i].slave,
376 			    msgs[i].buf, msgs[i].len, &lenwrote);
377 	}
378 	return (error);
379 }
380