mv_twsi.c revision 194015 
1/*-
2 * Copyright (C) 2008 MARVELL INTERNATIONAL LTD.
3 * All rights reserved.
4 *
5 * Developed by Semihalf.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of MARVELL nor the names of contributors
16 *    may be used to endorse or promote products derived from this software
17 *    without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32/*
33 * Driver for the TWSI (aka I2C, aka IIC) bus controller found on Marvell
34 * SoCs. Supports master operation only, and works in polling mode.
35 *
36 * Calls to DELAY() are needed per Application Note AN-179 "TWSI Software
37 * Guidelines for Discovery(TM), Horizon (TM) and Feroceon(TM) Devices".
38 */
39
40#include <sys/cdefs.h>
41__FBSDID("$FreeBSD: head/sys/arm/mv/twsi.c 194015 2009-06-11 17:05:13Z avg $");
42
43#include <sys/param.h>
44#include <sys/systm.h>
45#include <sys/bus.h>
46#include <sys/kernel.h>
47#include <sys/module.h>
48#include <sys/resource.h>
49
50#include <machine/bus.h>
51#include <machine/resource.h>
52
53#include <sys/rman.h>
54
55#include <sys/lock.h>
56#include <sys/mutex.h>
57
58#include <dev/iicbus/iiconf.h>
59#include <dev/iicbus/iicbus.h>
60#include "iicbus_if.h"
61
62#define MV_TWSI_NAME		"twsi"
63
64#define TWSI_SLAVE_ADDR		0x00
65#define TWSI_EXT_SLAVE_ADDR	0x10
66#define TWSI_DATA		0x04
67
68#define TWSI_CONTROL		0x08
69#define TWSI_CONTROL_ACK	(1 << 2)
70#define TWSI_CONTROL_IFLG	(1 << 3)
71#define TWSI_CONTROL_STOP	(1 << 4)
72#define TWSI_CONTROL_START	(1 << 5)
73#define TWSI_CONTROL_TWSIEN	(1 << 6)
74#define TWSI_CONTROL_INTEN	(1 << 7)
75
76#define TWSI_STATUS			0x0c
77#define TWSI_STATUS_START		0x08
78#define TWSI_STATUS_RPTD_START		0x10
79#define TWSI_STATUS_ADDR_W_ACK		0x18
80#define TWSI_STATUS_DATA_WR_ACK		0x28
81#define TWSI_STATUS_ADDR_R_ACK		0x40
82#define TWSI_STATUS_DATA_RD_ACK		0x50
83#define TWSI_STATUS_DATA_RD_NOACK	0x58
84
85#define TWSI_BAUD_RATE		0x0c
86#define TWSI_BAUD_RATE_94DOT3	0x53 /* N=3, M=10 */
87#define TWSI_BAUD_RATE_74DOT1	0x6b /* N=3, M=13 */
88#define TWSI_BAUD_RATE_51DOT8	0x4c /* N=4, M=9  */
89#define TWSI_BAUD_RATE_99DOT7	0x66 /* N=6, M=12 */
90
91#define TWSI_SOFT_RESET		0x1c
92
93#define TWSI_DEBUG
94#undef TWSI_DEBUG
95
96#ifdef  TWSI_DEBUG
97#define debugf(fmt, args...) do { printf("%s(): ", __func__); printf(fmt,##args); } while (0)
98#else
99#define debugf(fmt, args...)
100#endif
101
102struct mv_twsi_softc {
103	device_t	dev;
104	struct resource	*res[1];	/* SYS_RES_MEMORY */
105	struct mtx	mutex;
106	device_t	iicbus;
107};
108
109static int mv_twsi_probe(device_t);
110static int mv_twsi_attach(device_t);
111static int mv_twsi_detach(device_t);
112
113static int mv_twsi_reset(device_t dev, u_char speed, u_char addr,
114    u_char *oldaddr);
115static int mv_twsi_repeated_start(device_t dev, u_char slave, int timeout);
116static int mv_twsi_start(device_t dev, u_char slave, int timeout);
117static int mv_twsi_stop(device_t dev);
118static int mv_twsi_read(device_t dev, char *buf, int len, int *read, int last,
119    int delay);
120static int mv_twsi_write(device_t dev, const char *buf, int len, int *sent,
121    int timeout);
122
123static struct resource_spec res_spec[] = {
124	{ SYS_RES_MEMORY, 0, RF_ACTIVE },
125	{ -1, 0 }
126};
127
128static device_method_t mv_twsi_methods[] = {
129	/* device interface */
130	DEVMETHOD(device_probe,		mv_twsi_probe),
131	DEVMETHOD(device_attach,	mv_twsi_attach),
132	DEVMETHOD(device_detach,	mv_twsi_detach),
133
134	/* iicbus interface */
135	DEVMETHOD(iicbus_callback, iicbus_null_callback),
136	DEVMETHOD(iicbus_repeated_start, mv_twsi_repeated_start),
137	DEVMETHOD(iicbus_start,		mv_twsi_start),
138	DEVMETHOD(iicbus_stop,		mv_twsi_stop),
139	DEVMETHOD(iicbus_write,		mv_twsi_write),
140	DEVMETHOD(iicbus_read,		mv_twsi_read),
141	DEVMETHOD(iicbus_reset,		mv_twsi_reset),
142	DEVMETHOD(iicbus_transfer,	iicbus_transfer_gen),
143	{ 0, 0 }
144};
145
146static devclass_t mv_twsi_devclass;
147
148static driver_t mv_twsi_driver = {
149	MV_TWSI_NAME,
150	mv_twsi_methods,
151	sizeof(struct mv_twsi_softc),
152};
153
154DRIVER_MODULE(twsi, mbus, mv_twsi_driver, mv_twsi_devclass, 0, 0);
155DRIVER_MODULE(iicbus, twsi, iicbus_driver, iicbus_devclass, 0, 0);
156MODULE_DEPEND(twsi, iicbus, 1, 1, 1);
157
158static __inline uint32_t
159TWSI_READ(struct mv_twsi_softc *sc, bus_size_t off)
160{
161
162	return (bus_read_4(sc->res[0], off));
163}
164
165static __inline void
166TWSI_WRITE(struct mv_twsi_softc *sc, bus_size_t off, uint32_t val)
167{
168
169	bus_write_4(sc->res[0], off, val);
170}
171
172static __inline void
173twsi_control_clear(struct mv_twsi_softc *sc, uint32_t mask)
174{
175	uint32_t val;
176
177	val = TWSI_READ(sc, TWSI_CONTROL);
178	val &= ~mask;
179	TWSI_WRITE(sc, TWSI_CONTROL, val);
180}
181
182static __inline void
183twsi_control_set(struct mv_twsi_softc *sc, uint32_t mask)
184{
185	uint32_t val;
186
187	val = TWSI_READ(sc, TWSI_CONTROL);
188	val |= mask;
189	TWSI_WRITE(sc, TWSI_CONTROL, val);
190}
191
192static __inline void
193twsi_clear_iflg(struct mv_twsi_softc *sc)
194{
195
196	DELAY(1000);
197	twsi_control_clear(sc, TWSI_CONTROL_IFLG);
198	DELAY(1000);
199}
200
201
202/*
203 * timeout given in us
204 * returns
205 *   0 on sucessfull mask change
206 *   non-zero on timeout
207 */
208static int
209twsi_poll_ctrl(struct mv_twsi_softc *sc, int timeout, uint32_t mask)
210{
211
212	timeout /= 10;
213	while (!(TWSI_READ(sc, TWSI_CONTROL) & mask)) {
214		DELAY(10);
215		if (--timeout < 0)
216			return (timeout);
217	}
218	return (0);
219}
220
221
222/*
223 * 'timeout' is given in us. Note also that timeout handling is not exact --
224 * twsi_locked_start() total wait can be more than 2 x timeout
225 * (twsi_poll_ctrl() is called twice). 'mask' can be either TWSI_STATUS_START
226 * or TWSI_STATUS_RPTD_START
227 */
228static int
229twsi_locked_start(device_t dev, struct mv_twsi_softc *sc, int32_t mask,
230    u_char slave, int timeout)
231{
232	int read_access, iflg_set = 0;
233	uint32_t status;
234
235	mtx_assert(&sc->mutex, MA_OWNED);
236
237	if (mask == TWSI_STATUS_RPTD_START)
238		/* read IFLG to know if it should be cleared later; from NBSD */
239		iflg_set = TWSI_READ(sc, TWSI_CONTROL) & TWSI_CONTROL_IFLG;
240
241	twsi_control_set(sc, TWSI_CONTROL_START);
242
243	if (mask == TWSI_STATUS_RPTD_START && iflg_set) {
244		debugf("IFLG set, clearing\n");
245		twsi_clear_iflg(sc);
246	}
247
248	/*
249	 * Without this delay we timeout checking IFLG if the timeout is 0.
250	 * NBSD driver always waits here too.
251	 */
252	DELAY(1000);
253
254	if (twsi_poll_ctrl(sc, timeout, TWSI_CONTROL_IFLG)) {
255		debugf("timeout sending %sSTART condition\n",
256		    mask == TWSI_STATUS_START ? "" : "repeated ");
257		return (IIC_ETIMEOUT);
258	}
259
260	status = TWSI_READ(sc, TWSI_STATUS);
261	if (status != mask) {
262		debugf("wrong status (%02x) after sending %sSTART condition\n",
263		    status, mask == TWSI_STATUS_START ? "" : "repeated ");
264		return (IIC_ESTATUS);
265	}
266
267	TWSI_WRITE(sc, TWSI_DATA, slave);
268	DELAY(1000);
269	twsi_clear_iflg(sc);
270
271	if (twsi_poll_ctrl(sc, timeout, TWSI_CONTROL_IFLG)) {
272		debugf("timeout sending slave address\n");
273		return (IIC_ETIMEOUT);
274	}
275
276	read_access = (slave & 0x1) ? 1 : 0;
277	status = TWSI_READ(sc, TWSI_STATUS);
278	if (status != (read_access ?
279	    TWSI_STATUS_ADDR_R_ACK : TWSI_STATUS_ADDR_W_ACK)) {
280		debugf("no ACK (status: %02x) after sending slave address\n",
281		    status);
282		return (IIC_ENOACK);
283	}
284
285	return (IIC_NOERR);
286}
287
288static int
289mv_twsi_probe(device_t dev)
290{
291
292	device_set_desc(dev, "Marvell Integrated I2C Bus Controller");
293	return (BUS_PROBE_DEFAULT);
294}
295
296static int
297mv_twsi_attach(device_t dev)
298{
299	struct mv_twsi_softc *sc;
300
301	sc = device_get_softc(dev);
302	sc->dev = dev;
303
304	mtx_init(&sc->mutex, device_get_nameunit(dev), MV_TWSI_NAME, MTX_DEF);
305
306	/* Allocate IO resources */
307	if (bus_alloc_resources(dev, res_spec, sc->res)) {
308		device_printf(dev, "could not allocate resources\n");
309		mv_twsi_detach(dev);
310		return (ENXIO);
311	}
312
313	sc->iicbus = device_add_child(dev, "iicbus", -1);
314	if (sc->iicbus == NULL) {
315		device_printf(dev, "could not add iicbus child\n");
316		mv_twsi_detach(dev);
317		return (ENXIO);
318	}
319
320	bus_generic_attach(dev);
321	return (0);
322}
323
324static int
325mv_twsi_detach(device_t dev)
326{
327	struct mv_twsi_softc *sc;
328	int rv;
329
330	sc = device_get_softc(dev);
331
332	if ((rv = bus_generic_detach(dev)) != 0)
333		return (rv);
334
335	if (sc->iicbus != NULL)
336		if ((rv = device_delete_child(dev, sc->iicbus)) != 0)
337			return (rv);
338
339	bus_release_resources(dev, res_spec, sc->res);
340
341	mtx_destroy(&sc->mutex);
342	return (0);
343}
344
345/*
346 * Only slave mode supported, disregard [old]addr
347 */
348static int
349mv_twsi_reset(device_t dev, u_char speed, u_char addr, u_char *oldaddr)
350{
351	struct mv_twsi_softc *sc;
352	uint32_t baud_rate;
353
354	sc = device_get_softc(dev);
355
356	switch (speed) {
357	case IIC_SLOW:
358		baud_rate = TWSI_BAUD_RATE_51DOT8;
359		break;
360	case IIC_FAST:
361		baud_rate = TWSI_BAUD_RATE_51DOT8;
362		break;
363	case IIC_UNKNOWN:
364	case IIC_FASTEST:
365	default:
366		baud_rate = TWSI_BAUD_RATE_99DOT7;
367		break;
368	}
369
370	mtx_lock(&sc->mutex);
371	TWSI_WRITE(sc, TWSI_SOFT_RESET, 0x0);
372	DELAY(2000);
373	TWSI_WRITE(sc, TWSI_BAUD_RATE, baud_rate);
374	TWSI_WRITE(sc, TWSI_CONTROL, TWSI_CONTROL_TWSIEN | TWSI_CONTROL_ACK);
375	DELAY(1000);
376	mtx_unlock(&sc->mutex);
377
378	return (0);
379}
380
381/*
382 * timeout is given in us
383 */
384static int
385mv_twsi_repeated_start(device_t dev, u_char slave, int timeout)
386{
387	struct mv_twsi_softc *sc;
388	int rv;
389
390	sc = device_get_softc(dev);
391
392	mtx_lock(&sc->mutex);
393	rv = twsi_locked_start(dev, sc, TWSI_STATUS_RPTD_START, slave,
394	    timeout);
395	mtx_unlock(&sc->mutex);
396
397	if (rv) {
398		mv_twsi_stop(dev);
399		return (rv);
400	} else
401		return (IIC_NOERR);
402}
403
404/*
405 * timeout is given in us
406 */
407static int
408mv_twsi_start(device_t dev, u_char slave, int timeout)
409{
410	struct mv_twsi_softc *sc;
411	int rv;
412
413	sc = device_get_softc(dev);
414
415	mtx_lock(&sc->mutex);
416	rv = twsi_locked_start(dev, sc, TWSI_STATUS_START, slave, timeout);
417	mtx_unlock(&sc->mutex);
418
419	if (rv) {
420		mv_twsi_stop(dev);
421		return (rv);
422	} else
423		return (IIC_NOERR);
424}
425
426static int
427mv_twsi_stop(device_t dev)
428{
429	struct mv_twsi_softc *sc;
430
431	sc = device_get_softc(dev);
432
433	mtx_lock(&sc->mutex);
434	twsi_control_set(sc, TWSI_CONTROL_STOP);
435	DELAY(1000);
436	twsi_clear_iflg(sc);
437	mtx_unlock(&sc->mutex);
438
439	return (IIC_NOERR);
440}
441
442static int
443mv_twsi_read(device_t dev, char *buf, int len, int *read, int last, int delay)
444{
445	struct mv_twsi_softc *sc;
446	uint32_t status;
447	int last_byte, rv;
448
449	sc = device_get_softc(dev);
450
451	mtx_lock(&sc->mutex);
452	*read = 0;
453	while (*read < len) {
454		/*
455		 * Check if we are reading last byte of the last buffer,
456		 * do not send ACK then, per I2C specs
457		 */
458		last_byte = ((*read == len - 1) && last) ? 1 : 0;
459		if (last_byte)
460			twsi_control_clear(sc, TWSI_CONTROL_ACK);
461		else
462			twsi_control_set(sc, TWSI_CONTROL_ACK);
463
464		DELAY (1000);
465		twsi_clear_iflg(sc);
466
467		if (twsi_poll_ctrl(sc, delay, TWSI_CONTROL_IFLG)) {
468			debugf("timeout reading data\n");
469			rv = IIC_ETIMEOUT;
470			goto out;
471		}
472
473		status = TWSI_READ(sc, TWSI_STATUS);
474		if (status != (last_byte ?
475		    TWSI_STATUS_DATA_RD_NOACK : TWSI_STATUS_DATA_RD_ACK)) {
476			debugf("wrong status (%02x) while reading\n", status);
477			rv = IIC_ESTATUS;
478			goto out;
479		}
480
481		*buf++ = TWSI_READ(sc, TWSI_DATA);
482		(*read)++;
483	}
484	rv = IIC_NOERR;
485out:
486	mtx_unlock(&sc->mutex);
487	return (rv);
488}
489
490static int
491mv_twsi_write(device_t dev, const char *buf, int len, int *sent, int timeout)
492{
493	struct mv_twsi_softc *sc;
494	uint32_t status;
495	int rv;
496
497	sc = device_get_softc(dev);
498
499	mtx_lock(&sc->mutex);
500	*sent = 0;
501	while (*sent < len) {
502		TWSI_WRITE(sc, TWSI_DATA, *buf++);
503
504		twsi_clear_iflg(sc);
505		if (twsi_poll_ctrl(sc, timeout, TWSI_CONTROL_IFLG)) {
506			debugf("timeout writing data\n");
507			rv = IIC_ETIMEOUT;
508			goto out;
509		}
510
511		status = TWSI_READ(sc, TWSI_STATUS);
512		if (status != TWSI_STATUS_DATA_WR_ACK) {
513			debugf("wrong status (%02x) while writing\n", status);
514			rv = IIC_ESTATUS;
515			goto out;
516		}
517		(*sent)++;
518	}
519	rv = IIC_NOERR;
520out:
521	mtx_unlock(&sc->mutex);
522	return (rv);
523}
524