1 /*-
2 * Copyright (c) 2016 Michal Meloun <mmel@FreeBSD.org>
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 /*
29 * I2C driver for Tegra SoCs.
30 */
31 #include <sys/param.h>
32 #include <sys/systm.h>
33 #include <sys/bus.h>
34 #include <sys/kernel.h>
35 #include <sys/limits.h>
36 #include <sys/module.h>
37 #include <sys/resource.h>
38
39 #include <machine/bus.h>
40 #include <machine/resource.h>
41 #include <sys/rman.h>
42
43 #include <sys/lock.h>
44 #include <sys/mutex.h>
45
46 #include <dev/clk/clk.h>
47 #include <dev/hwreset/hwreset.h>
48 #include <dev/iicbus/iiconf.h>
49 #include <dev/iicbus/iicbus.h>
50 #include <dev/ofw/ofw_bus.h>
51 #include <dev/ofw/ofw_bus_subr.h>
52
53 #include "iicbus_if.h"
54
55 #define I2C_CNFG 0x000
56 #define I2C_CNFG_MSTR_CLR_BUS_ON_TIMEOUT (1 << 15)
57 #define I2C_CNFG_DEBOUNCE_CNT(x) (((x) & 0x07) << 12)
58 #define I2C_CNFG_NEW_MASTER_FSM (1 << 11)
59 #define I2C_CNFG_PACKET_MODE_EN (1 << 10)
60 #define I2C_CNFG_SEND (1 << 9)
61 #define I2C_CNFG_NOACK (1 << 8)
62 #define I2C_CNFG_CMD2 (1 << 7)
63 #define I2C_CNFG_CMD1 (1 << 6)
64 #define I2C_CNFG_START (1 << 5)
65 #define I2C_CNFG_SLV2 (1 << 4)
66 #define I2C_CNFG_LENGTH_SHIFT 1
67 #define I2C_CNFG_LENGTH_MASK 0x7
68 #define I2C_CNFG_A_MOD (1 << 0)
69
70 #define I2C_CMD_ADDR0 0x004
71 #define I2C_CMD_ADDR1 0x008
72 #define I2C_CMD_DATA1 0x00c
73 #define I2C_CMD_DATA2 0x010
74 #define I2C_STATUS 0x01c
75 #define I2C_SL_CNFG 0x020
76 #define I2C_SL_RCVD 0x024
77 #define I2C_SL_STATUS 0x028
78 #define I2C_SL_ADDR1 0x02c
79 #define I2C_SL_ADDR2 0x030
80 #define I2C_TLOW_SEXT 0x034
81 #define I2C_SL_DELAY_COUNT 0x03c
82 #define I2C_SL_INT_MASK 0x040
83 #define I2C_SL_INT_SOURCE 0x044
84 #define I2C_SL_INT_SET 0x048
85 #define I2C_TX_PACKET_FIFO 0x050
86 #define I2C_RX_FIFO 0x054
87 #define I2C_PACKET_TRANSFER_STATUS 0x058
88 #define I2C_FIFO_CONTROL 0x05c
89 #define I2C_FIFO_CONTROL_SLV_TX_FIFO_TRIG(x) (((x) & 0x07) << 13)
90 #define I2C_FIFO_CONTROL_SLV_RX_FIFO_TRIG(x) (((x) & 0x07) << 10)
91 #define I2C_FIFO_CONTROL_SLV_TX_FIFO_FLUSH (1 << 9)
92 #define I2C_FIFO_CONTROL_SLV_RX_FIFO_FLUSH (1 << 8)
93 #define I2C_FIFO_CONTROL_TX_FIFO_TRIG(x) (((x) & 0x07) << 5)
94 #define I2C_FIFO_CONTROL_RX_FIFO_TRIG(x) (((x) & 0x07) << 2)
95 #define I2C_FIFO_CONTROL_TX_FIFO_FLUSH (1 << 1)
96 #define I2C_FIFO_CONTROL_RX_FIFO_FLUSH (1 << 0)
97
98 #define I2C_FIFO_STATUS 0x060
99 #define I2C_FIFO_STATUS_SLV_XFER_ERR_REASON (1 << 25)
100 #define I2C_FIFO_STATUS_TX_FIFO_SLV_EMPTY_CNT(x) (((x) >> 20) & 0xF)
101 #define I2C_FIFO_STATUS_RX_FIFO_SLV_FULL_CNT(x) (((x) >> 16) & 0xF)
102 #define I2C_FIFO_STATUS_TX_FIFO_EMPTY_CNT(x) (((x) >> 4) & 0xF)
103 #define I2C_FIFO_STATUS_RX_FIFO_FULL_CNT(x) (((x) >> 0) & 0xF)
104
105 #define I2C_INTERRUPT_MASK_REGISTER 0x064
106 #define I2C_INTERRUPT_STATUS_REGISTER 0x068
107 #define I2C_INT_SLV_ACK_WITHHELD (1 << 28)
108 #define I2C_INT_SLV_RD2WR (1 << 27)
109 #define I2C_INT_SLV_WR2RD (1 << 26)
110 #define I2C_INT_SLV_PKT_XFER_ERR (1 << 25)
111 #define I2C_INT_SLV_TX_BUFFER_REQ (1 << 24)
112 #define I2C_INT_SLV_RX_BUFFER_FILLED (1 << 23)
113 #define I2C_INT_SLV_PACKET_XFER_COMPLETE (1 << 22)
114 #define I2C_INT_SLV_TFIFO_OVF (1 << 21)
115 #define I2C_INT_SLV_RFIFO_UNF (1 << 20)
116 #define I2C_INT_SLV_TFIFO_DATA_REQ (1 << 17)
117 #define I2C_INT_SLV_RFIFO_DATA_REQ (1 << 16)
118 #define I2C_INT_BUS_CLEAR_DONE (1 << 11)
119 #define I2C_INT_TLOW_MEXT_TIMEOUT (1 << 10)
120 #define I2C_INT_TLOW_SEXT_TIMEOUT (1 << 9)
121 #define I2C_INT_TIMEOUT (1 << 8)
122 #define I2C_INT_PACKET_XFER_COMPLETE (1 << 7)
123 #define I2C_INT_ALL_PACKETS_XFER_COMPLETE (1 << 6)
124 #define I2C_INT_TFIFO_OVR (1 << 5)
125 #define I2C_INT_RFIFO_UNF (1 << 4)
126 #define I2C_INT_NOACK (1 << 3)
127 #define I2C_INT_ARB_LOST (1 << 2)
128 #define I2C_INT_TFIFO_DATA_REQ (1 << 1)
129 #define I2C_INT_RFIFO_DATA_REQ (1 << 0)
130 #define I2C_ERROR_MASK (I2C_INT_ARB_LOST | I2C_INT_NOACK | \
131 I2C_INT_RFIFO_UNF | I2C_INT_TFIFO_OVR)
132
133 #define I2C_CLK_DIVISOR 0x06c
134 #define I2C_CLK_DIVISOR_STD_FAST_MODE_SHIFT 16
135 #define I2C_CLK_DIVISOR_STD_FAST_MODE_MASK 0xffff
136 #define I2C_CLK_DIVISOR_HSMODE_SHIFT 0
137 #define I2C_CLK_DIVISOR_HSMODE_MASK 0xffff
138 #define I2C_INTERRUPT_SOURCE_REGISTER 0x070
139 #define I2C_INTERRUPT_SET_REGISTER 0x074
140 #define I2C_SLV_TX_PACKET_FIFO 0x07c
141 #define I2C_SLV_PACKET_STATUS 0x080
142 #define I2C_BUS_CLEAR_CONFIG 0x084
143 #define I2C_BUS_CLEAR_CONFIG_BC_SCLK_THRESHOLD(x) (((x) & 0xFF) << 16)
144 #define I2C_BUS_CLEAR_CONFIG_BC_STOP_COND (1 << 2)
145 #define I2C_BUS_CLEAR_CONFIG_BC_TERMINATE (1 << 1)
146 #define I2C_BUS_CLEAR_CONFIG_BC_ENABLE (1 << 0)
147
148 #define I2C_BUS_CLEAR_STATUS 0x088
149 #define I2C_BUS_CLEAR_STATUS_BC_STATUS (1 << 0)
150
151 #define I2C_CONFIG_LOAD 0x08c
152 #define I2C_CONFIG_LOAD_TIMEOUT_CONFIG_LOAD (1 << 2)
153 #define I2C_CONFIG_LOAD_SLV_CONFIG_LOAD (1 << 1)
154 #define I2C_CONFIG_LOAD_MSTR_CONFIG_LOAD (1 << 0)
155
156 #define I2C_INTERFACE_TIMING_0 0x094
157 #define I2C_INTERFACE_TIMING_1 0x098
158 #define I2C_HS_INTERFACE_TIMING_0 0x09c
159 #define I2C_HS_INTERFACE_TIMING_1 0x0a0
160
161 /* Protocol header 0 */
162 #define PACKET_HEADER0_HEADER_SIZE_SHIFT 28
163 #define PACKET_HEADER0_HEADER_SIZE_MASK 0x3
164 #define PACKET_HEADER0_PACKET_ID_SHIFT 16
165 #define PACKET_HEADER0_PACKET_ID_MASK 0xff
166 #define PACKET_HEADER0_CONT_ID_SHIFT 12
167 #define PACKET_HEADER0_CONT_ID_MASK 0xf
168 #define PACKET_HEADER0_PROTOCOL_I2C (1 << 4)
169 #define PACKET_HEADER0_TYPE_SHIFT 0
170 #define PACKET_HEADER0_TYPE_MASK 0x7
171
172 /* I2C header */
173 #define I2C_HEADER_HIGHSPEED_MODE (1 << 22)
174 #define I2C_HEADER_CONT_ON_NAK (1 << 21)
175 #define I2C_HEADER_SEND_START_BYTE (1 << 20)
176 #define I2C_HEADER_READ (1 << 19)
177 #define I2C_HEADER_10BIT_ADDR (1 << 18)
178 #define I2C_HEADER_IE_ENABLE (1 << 17)
179 #define I2C_HEADER_REPEAT_START (1 << 16)
180 #define I2C_HEADER_CONTINUE_XFER (1 << 15)
181 #define I2C_HEADER_MASTER_ADDR_SHIFT 12
182 #define I2C_HEADER_MASTER_ADDR_MASK 0x7
183 #define I2C_HEADER_SLAVE_ADDR_SHIFT 0
184 #define I2C_HEADER_SLAVE_ADDR_MASK 0x3ff
185
186 #define I2C_CLK_DIVISOR_STD_FAST_MODE 0x19
187 #define I2C_CLK_MULTIPLIER_STD_FAST_MODE 8
188
189 #define I2C_REQUEST_TIMEOUT (5 * hz)
190
191 #define WR4(_sc, _r, _v) bus_write_4((_sc)->mem_res, (_r), (_v))
192 #define RD4(_sc, _r) bus_read_4((_sc)->mem_res, (_r))
193
194 #define LOCK(_sc) mtx_lock(&(_sc)->mtx)
195 #define UNLOCK(_sc) mtx_unlock(&(_sc)->mtx)
196 #define SLEEP(_sc, timeout) \
197 mtx_sleep(sc, &sc->mtx, 0, "i2cbuswait", timeout);
198 #define LOCK_INIT(_sc) \
199 mtx_init(&_sc->mtx, device_get_nameunit(_sc->dev), "tegra_i2c", MTX_DEF)
200 #define LOCK_DESTROY(_sc) mtx_destroy(&_sc->mtx)
201 #define ASSERT_LOCKED(_sc) mtx_assert(&_sc->mtx, MA_OWNED)
202 #define ASSERT_UNLOCKED(_sc) mtx_assert(&_sc->mtx, MA_NOTOWNED)
203
204 static struct ofw_compat_data compat_data[] = {
205 {"nvidia,tegra124-i2c", 1},
206 {"nvidia,tegra210-i2c", 1},
207 {NULL, 0}
208 };
209 enum tegra_i2c_xfer_type {
210 XFER_STOP, /* Send stop condition after xfer */
211 XFER_REPEAT_START, /* Send repeated start after xfer */
212 XFER_CONTINUE /* Don't send nothing */
213 } ;
214
215 struct tegra_i2c_softc {
216 device_t dev;
217 struct mtx mtx;
218
219 struct resource *mem_res;
220 struct resource *irq_res;
221 void *irq_h;
222
223 device_t iicbus;
224 clk_t clk;
225 hwreset_t reset;
226 uint32_t core_freq;
227 uint32_t bus_freq;
228 int bus_inuse;
229
230 struct iic_msg *msg;
231 int msg_idx;
232 uint32_t bus_err;
233 int done;
234 };
235
236 static int
tegra_i2c_flush_fifo(struct tegra_i2c_softc * sc)237 tegra_i2c_flush_fifo(struct tegra_i2c_softc *sc)
238 {
239 int timeout;
240 uint32_t reg;
241
242 reg = RD4(sc, I2C_FIFO_CONTROL);
243 reg |= I2C_FIFO_CONTROL_TX_FIFO_FLUSH | I2C_FIFO_CONTROL_RX_FIFO_FLUSH;
244 WR4(sc, I2C_FIFO_CONTROL, reg);
245
246 timeout = 10;
247 while (timeout > 0) {
248 reg = RD4(sc, I2C_FIFO_CONTROL);
249 reg &= I2C_FIFO_CONTROL_TX_FIFO_FLUSH |
250 I2C_FIFO_CONTROL_RX_FIFO_FLUSH;
251 if (reg == 0)
252 break;
253 DELAY(10);
254 }
255 if (timeout <= 0) {
256 device_printf(sc->dev, "FIFO flush timedout\n");
257 return (ETIMEDOUT);
258 }
259 return (0);
260 }
261
262 static void
tegra_i2c_setup_clk(struct tegra_i2c_softc * sc,int clk_freq)263 tegra_i2c_setup_clk(struct tegra_i2c_softc *sc, int clk_freq)
264 {
265 int div;
266
267 div = ((sc->core_freq / clk_freq) / 10) - 1;
268 if ((sc->core_freq / (10 * (div + 1))) > clk_freq)
269 div++;
270 if (div > 65535)
271 div = 65535;
272 WR4(sc, I2C_CLK_DIVISOR,
273 (1 << I2C_CLK_DIVISOR_HSMODE_SHIFT) |
274 (div << I2C_CLK_DIVISOR_STD_FAST_MODE_SHIFT));
275 }
276
277 static void
tegra_i2c_bus_clear(struct tegra_i2c_softc * sc)278 tegra_i2c_bus_clear(struct tegra_i2c_softc *sc)
279 {
280 int timeout;
281 uint32_t reg, status;
282
283 WR4(sc, I2C_BUS_CLEAR_CONFIG,
284 I2C_BUS_CLEAR_CONFIG_BC_SCLK_THRESHOLD(18) |
285 I2C_BUS_CLEAR_CONFIG_BC_STOP_COND |
286 I2C_BUS_CLEAR_CONFIG_BC_TERMINATE);
287
288 WR4(sc, I2C_CONFIG_LOAD, I2C_CONFIG_LOAD_MSTR_CONFIG_LOAD);
289 for (timeout = 1000; timeout > 0; timeout--) {
290 if (RD4(sc, I2C_CONFIG_LOAD) == 0)
291 break;
292 DELAY(10);
293 }
294 if (timeout <= 0)
295 device_printf(sc->dev, "config load timeouted\n");
296 reg = RD4(sc, I2C_BUS_CLEAR_CONFIG);
297 reg |= I2C_BUS_CLEAR_CONFIG_BC_ENABLE;
298 WR4(sc, I2C_BUS_CLEAR_CONFIG,reg);
299
300 for (timeout = 1000; timeout > 0; timeout--) {
301 if ((RD4(sc, I2C_BUS_CLEAR_CONFIG) &
302 I2C_BUS_CLEAR_CONFIG_BC_ENABLE) == 0)
303 break;
304 DELAY(10);
305 }
306 if (timeout <= 0)
307 device_printf(sc->dev, "bus clear timeouted\n");
308
309 status = RD4(sc, I2C_BUS_CLEAR_STATUS);
310 if ((status & I2C_BUS_CLEAR_STATUS_BC_STATUS) == 0)
311 device_printf(sc->dev, "bus clear failed\n");
312 }
313
314 static int
tegra_i2c_hw_init(struct tegra_i2c_softc * sc)315 tegra_i2c_hw_init(struct tegra_i2c_softc *sc)
316 {
317 int rv, timeout;
318
319 /* Reset the core. */
320 rv = hwreset_assert(sc->reset);
321 if (rv != 0) {
322 device_printf(sc->dev, "Cannot assert reset\n");
323 return (rv);
324 }
325 DELAY(10);
326 rv = hwreset_deassert(sc->reset);
327 if (rv != 0) {
328 device_printf(sc->dev, "Cannot clear reset\n");
329 return (rv);
330 }
331
332 WR4(sc, I2C_INTERRUPT_MASK_REGISTER, 0);
333 WR4(sc, I2C_INTERRUPT_STATUS_REGISTER, 0xFFFFFFFF);
334 WR4(sc, I2C_CNFG, I2C_CNFG_NEW_MASTER_FSM | I2C_CNFG_PACKET_MODE_EN |
335 I2C_CNFG_DEBOUNCE_CNT(2));
336
337 tegra_i2c_setup_clk(sc, sc->bus_freq);
338
339 WR4(sc, I2C_FIFO_CONTROL, I2C_FIFO_CONTROL_TX_FIFO_TRIG(7) |
340 I2C_FIFO_CONTROL_RX_FIFO_TRIG(0));
341
342 WR4(sc, I2C_CONFIG_LOAD, I2C_CONFIG_LOAD_MSTR_CONFIG_LOAD);
343 for (timeout = 1000; timeout > 0; timeout--) {
344 if (RD4(sc, I2C_CONFIG_LOAD) == 0)
345 break;
346 DELAY(10);
347 }
348 if (timeout <= 0)
349 device_printf(sc->dev, "config load timeouted\n");
350
351 tegra_i2c_bus_clear(sc);
352 return (0);
353 }
354
355 static int
tegra_i2c_tx(struct tegra_i2c_softc * sc)356 tegra_i2c_tx(struct tegra_i2c_softc *sc)
357 {
358 uint32_t reg;
359 int cnt, i;
360
361 if (sc->msg_idx >= sc->msg->len)
362 panic("Invalid call to tegra_i2c_tx\n");
363
364 while(sc->msg_idx < sc->msg->len) {
365 reg = RD4(sc, I2C_FIFO_STATUS);
366 if (I2C_FIFO_STATUS_TX_FIFO_EMPTY_CNT(reg) == 0)
367 break;
368 cnt = min(4, sc->msg->len - sc->msg_idx);
369 reg = 0;
370 for (i = 0; i < cnt; i++) {
371 reg |= sc->msg->buf[sc->msg_idx] << (i * 8);
372 sc->msg_idx++;
373 }
374 WR4(sc, I2C_TX_PACKET_FIFO, reg);
375 }
376 if (sc->msg_idx >= sc->msg->len)
377 return (0);
378 return (sc->msg->len - sc->msg_idx - 1);
379 }
380
381 static int
tegra_i2c_rx(struct tegra_i2c_softc * sc)382 tegra_i2c_rx(struct tegra_i2c_softc *sc)
383 {
384 uint32_t reg;
385 int cnt, i;
386
387 if (sc->msg_idx >= sc->msg->len)
388 panic("Invalid call to tegra_i2c_rx\n");
389
390 while(sc->msg_idx < sc->msg->len) {
391 reg = RD4(sc, I2C_FIFO_STATUS);
392 if (I2C_FIFO_STATUS_RX_FIFO_FULL_CNT(reg) == 0)
393 break;
394 cnt = min(4, sc->msg->len - sc->msg_idx);
395 reg = RD4(sc, I2C_RX_FIFO);
396 for (i = 0; i < cnt; i++) {
397 sc->msg->buf[sc->msg_idx] = (reg >> (i * 8)) & 0xFF;
398 sc->msg_idx++;
399 }
400 }
401
402 if (sc->msg_idx >= sc->msg->len)
403 return (0);
404 return (sc->msg->len - sc->msg_idx - 1);
405 }
406
407 static void
tegra_i2c_intr(void * arg)408 tegra_i2c_intr(void *arg)
409 {
410 struct tegra_i2c_softc *sc;
411 uint32_t status, reg;
412 int rv;
413
414 sc = (struct tegra_i2c_softc *)arg;
415
416 LOCK(sc);
417 status = RD4(sc, I2C_INTERRUPT_SOURCE_REGISTER);
418 if (sc->msg == NULL) {
419 /* Unexpected interrupt - disable FIFOs, clear reset. */
420 reg = RD4(sc, I2C_INTERRUPT_MASK_REGISTER);
421 reg &= ~I2C_INT_TFIFO_DATA_REQ;
422 reg &= ~I2C_INT_RFIFO_DATA_REQ;
423 WR4(sc, I2C_INTERRUPT_MASK_REGISTER, 0);
424 WR4(sc, I2C_INTERRUPT_STATUS_REGISTER, status);
425 UNLOCK(sc);
426 return;
427 }
428
429 if ((status & I2C_ERROR_MASK) != 0) {
430 if (status & I2C_INT_NOACK)
431 sc->bus_err = IIC_ENOACK;
432 if (status & I2C_INT_ARB_LOST)
433 sc->bus_err = IIC_EBUSERR;
434 if ((status & I2C_INT_TFIFO_OVR) ||
435 (status & I2C_INT_RFIFO_UNF))
436 sc->bus_err = IIC_EBUSERR;
437 sc->done = 1;
438 } else if ((status & I2C_INT_RFIFO_DATA_REQ) &&
439 (sc->msg != NULL) && (sc->msg->flags & IIC_M_RD)) {
440 rv = tegra_i2c_rx(sc);
441 if (rv == 0) {
442 reg = RD4(sc, I2C_INTERRUPT_MASK_REGISTER);
443 reg &= ~I2C_INT_RFIFO_DATA_REQ;
444 WR4(sc, I2C_INTERRUPT_MASK_REGISTER, reg);
445 }
446 } else if ((status & I2C_INT_TFIFO_DATA_REQ) &&
447 (sc->msg != NULL) && !(sc->msg->flags & IIC_M_RD)) {
448 rv = tegra_i2c_tx(sc);
449 if (rv == 0) {
450 reg = RD4(sc, I2C_INTERRUPT_MASK_REGISTER);
451 reg &= ~I2C_INT_TFIFO_DATA_REQ;
452 WR4(sc, I2C_INTERRUPT_MASK_REGISTER, reg);
453 }
454 } else if ((status & I2C_INT_RFIFO_DATA_REQ) ||
455 (status & I2C_INT_TFIFO_DATA_REQ)) {
456 device_printf(sc->dev, "Unexpected data interrupt: 0x%08X\n",
457 status);
458 reg = RD4(sc, I2C_INTERRUPT_MASK_REGISTER);
459 reg &= ~I2C_INT_TFIFO_DATA_REQ;
460 reg &= ~I2C_INT_RFIFO_DATA_REQ;
461 WR4(sc, I2C_INTERRUPT_MASK_REGISTER, reg);
462 }
463 if (status & I2C_INT_PACKET_XFER_COMPLETE)
464 sc->done = 1;
465 WR4(sc, I2C_INTERRUPT_STATUS_REGISTER, status);
466 if (sc->done) {
467 WR4(sc, I2C_INTERRUPT_MASK_REGISTER, 0);
468 wakeup(&(sc->done));
469 }
470 UNLOCK(sc);
471 }
472
473 static void
tegra_i2c_start_msg(struct tegra_i2c_softc * sc,struct iic_msg * msg,enum tegra_i2c_xfer_type xtype)474 tegra_i2c_start_msg(struct tegra_i2c_softc *sc, struct iic_msg *msg,
475 enum tegra_i2c_xfer_type xtype)
476 {
477 uint32_t tmp, mask;
478
479 /* Packet header. */
480 tmp = (0 << PACKET_HEADER0_HEADER_SIZE_SHIFT) |
481 PACKET_HEADER0_PROTOCOL_I2C |
482 (1 << PACKET_HEADER0_CONT_ID_SHIFT) |
483 (1 << PACKET_HEADER0_PACKET_ID_SHIFT);
484 WR4(sc, I2C_TX_PACKET_FIFO, tmp);
485
486 /* Packet size. */
487 WR4(sc, I2C_TX_PACKET_FIFO, msg->len - 1);
488
489 /* I2C header. */
490 tmp = I2C_HEADER_IE_ENABLE;
491 if (xtype == XFER_CONTINUE)
492 tmp |= I2C_HEADER_CONTINUE_XFER;
493 else if (xtype == XFER_REPEAT_START)
494 tmp |= I2C_HEADER_REPEAT_START;
495 tmp |= msg->slave << I2C_HEADER_SLAVE_ADDR_SHIFT;
496 if (msg->flags & IIC_M_RD) {
497 tmp |= I2C_HEADER_READ;
498 tmp |= 1 << I2C_HEADER_SLAVE_ADDR_SHIFT;
499 } else
500 tmp &= ~(1 << I2C_HEADER_SLAVE_ADDR_SHIFT);
501
502 WR4(sc, I2C_TX_PACKET_FIFO, tmp);
503
504 /* Interrupt mask. */
505 mask = I2C_INT_NOACK | I2C_INT_ARB_LOST | I2C_INT_PACKET_XFER_COMPLETE;
506 if (msg->flags & IIC_M_RD)
507 mask |= I2C_INT_RFIFO_DATA_REQ;
508 else
509 mask |= I2C_INT_TFIFO_DATA_REQ;
510 WR4(sc, I2C_INTERRUPT_MASK_REGISTER, mask);
511 }
512
513 static int
tegra_i2c_poll(struct tegra_i2c_softc * sc)514 tegra_i2c_poll(struct tegra_i2c_softc *sc)
515 {
516 int timeout;
517
518 for(timeout = 10000; timeout > 0; timeout--) {
519 UNLOCK(sc);
520 tegra_i2c_intr(sc);
521 LOCK(sc);
522 if (sc->done != 0)
523 break;
524 DELAY(1);
525 }
526 if (timeout <= 0)
527 return (ETIMEDOUT);
528 return (0);
529 }
530
531 static int
tegra_i2c_transfer(device_t dev,struct iic_msg * msgs,uint32_t nmsgs)532 tegra_i2c_transfer(device_t dev, struct iic_msg *msgs, uint32_t nmsgs)
533 {
534 int rv, i;
535 struct tegra_i2c_softc *sc;
536 enum tegra_i2c_xfer_type xtype;
537
538 sc = device_get_softc(dev);
539 LOCK(sc);
540
541 /* Get the bus. */
542 while (sc->bus_inuse == 1)
543 SLEEP(sc, 0);
544 sc->bus_inuse = 1;
545
546 rv = 0;
547 for (i = 0; i < nmsgs; i++) {
548 sc->msg = &msgs[i];
549 sc->msg_idx = 0;
550 sc->bus_err = 0;
551 sc->done = 0;
552 /* Check for valid parameters. */
553 if (sc->msg == NULL || sc->msg->buf == NULL ||
554 sc->msg->len == 0) {
555 rv = EINVAL;
556 break;
557 }
558
559 /* Get flags for next transfer. */
560 if (i == (nmsgs - 1)) {
561 if (msgs[i].flags & IIC_M_NOSTOP)
562 xtype = XFER_CONTINUE;
563 else
564 xtype = XFER_STOP;
565 } else {
566 if (msgs[i + 1].flags & IIC_M_NOSTART)
567 xtype = XFER_CONTINUE;
568 else
569 xtype = XFER_REPEAT_START;
570 }
571 tegra_i2c_start_msg(sc, sc->msg, xtype);
572 if (cold)
573 rv = tegra_i2c_poll(sc);
574 else
575 rv = msleep(&sc->done, &sc->mtx, PZERO, "iic",
576 I2C_REQUEST_TIMEOUT);
577
578 WR4(sc, I2C_INTERRUPT_MASK_REGISTER, 0);
579 WR4(sc, I2C_INTERRUPT_STATUS_REGISTER, 0xFFFFFFFF);
580 if (rv == 0)
581 rv = sc->bus_err;
582 if (rv != 0)
583 break;
584 }
585
586 if (rv != 0) {
587 tegra_i2c_hw_init(sc);
588 tegra_i2c_flush_fifo(sc);
589 }
590
591 sc->msg = NULL;
592 sc->msg_idx = 0;
593 sc->bus_err = 0;
594 sc->done = 0;
595
596 /* Wake up the processes that are waiting for the bus. */
597 sc->bus_inuse = 0;
598 wakeup(sc);
599 UNLOCK(sc);
600
601 return (rv);
602 }
603
604 static int
tegra_i2c_iicbus_reset(device_t dev,u_char speed,u_char addr,u_char * oldaddr)605 tegra_i2c_iicbus_reset(device_t dev, u_char speed, u_char addr, u_char *oldaddr)
606 {
607 struct tegra_i2c_softc *sc;
608 int busfreq;
609
610 sc = device_get_softc(dev);
611 busfreq = IICBUS_GET_FREQUENCY(sc->iicbus, speed);
612 sc = device_get_softc(dev);
613 LOCK(sc);
614 tegra_i2c_setup_clk(sc, busfreq);
615 UNLOCK(sc);
616 return (0);
617 }
618
619 static int
tegra_i2c_probe(device_t dev)620 tegra_i2c_probe(device_t dev)
621 {
622 if (!ofw_bus_status_okay(dev))
623 return (ENXIO);
624
625 if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)
626 return (ENXIO);
627
628 return (BUS_PROBE_DEFAULT);
629 }
630
631 static int
tegra_i2c_attach(device_t dev)632 tegra_i2c_attach(device_t dev)
633 {
634 int rv, rid;
635 phandle_t node;
636 struct tegra_i2c_softc *sc;
637 uint64_t freq;
638
639 sc = device_get_softc(dev);
640 sc->dev = dev;
641 node = ofw_bus_get_node(dev);
642
643 LOCK_INIT(sc);
644
645 /* Get the memory resource for the register mapping. */
646 rid = 0;
647 sc->mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
648 RF_ACTIVE);
649 if (sc->mem_res == NULL) {
650 device_printf(dev, "Cannot map registers.\n");
651 rv = ENXIO;
652 goto fail;
653 }
654
655 /* Allocate our IRQ resource. */
656 rid = 0;
657 sc->irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
658 RF_ACTIVE);
659 if (sc->irq_res == NULL) {
660 device_printf(dev, "Cannot allocate interrupt.\n");
661 rv = ENXIO;
662 goto fail;
663 }
664
665 /* FDT resources. */
666 rv = clk_get_by_ofw_name(dev, 0, "div-clk", &sc->clk);
667 if (rv != 0) {
668 device_printf(dev, "Cannot get i2c clock: %d\n", rv);
669 goto fail;
670 }
671 rv = hwreset_get_by_ofw_name(sc->dev, 0, "i2c", &sc->reset);
672 if (rv != 0) {
673 device_printf(sc->dev, "Cannot get i2c reset\n");
674 return (ENXIO);
675 }
676 rv = OF_getencprop(node, "clock-frequency", &sc->bus_freq,
677 sizeof(sc->bus_freq));
678 if (rv != sizeof(sc->bus_freq)) {
679 sc->bus_freq = 100000;
680 }
681
682 /* Request maximum frequency for I2C block 136MHz (408MHz / 3). */
683 rv = clk_set_freq(sc->clk, 136000000, CLK_SET_ROUND_DOWN);
684 if (rv != 0) {
685 device_printf(dev, "Cannot set clock frequency\n");
686 goto fail;
687 }
688 rv = clk_get_freq(sc->clk, &freq);
689 if (rv != 0) {
690 device_printf(dev, "Cannot get clock frequency\n");
691 goto fail;
692 }
693 sc->core_freq = (uint32_t)freq;
694
695 rv = clk_enable(sc->clk);
696 if (rv != 0) {
697 device_printf(dev, "Cannot enable clock: %d\n", rv);
698 goto fail;
699 }
700
701 /* Init hardware. */
702 rv = tegra_i2c_hw_init(sc);
703 if (rv) {
704 device_printf(dev, "tegra_i2c_activate failed\n");
705 goto fail;
706 }
707
708 /* Setup interrupt. */
709 rv = bus_setup_intr(dev, sc->irq_res, INTR_TYPE_MISC | INTR_MPSAFE,
710 NULL, tegra_i2c_intr, sc, &sc->irq_h);
711 if (rv) {
712 device_printf(dev, "Cannot setup interrupt.\n");
713 goto fail;
714 }
715
716 /* Attach the iicbus. */
717 sc->iicbus = device_add_child(dev, "iicbus", DEVICE_UNIT_ANY);
718 if (sc->iicbus == NULL) {
719 device_printf(dev, "Could not allocate iicbus instance.\n");
720 rv = ENXIO;
721 goto fail;
722 }
723
724 /* Probe and attach the iicbus. */
725 bus_attach_children(dev);
726 return (0);
727
728 fail:
729 if (sc->irq_h != NULL)
730 bus_teardown_intr(dev, sc->irq_res, sc->irq_h);
731 if (sc->irq_res != NULL)
732 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq_res);
733 if (sc->mem_res != NULL)
734 bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->mem_res);
735 LOCK_DESTROY(sc);
736
737 return (rv);
738 }
739
740 static int
tegra_i2c_detach(device_t dev)741 tegra_i2c_detach(device_t dev)
742 {
743 struct tegra_i2c_softc *sc;
744 int error;
745
746 error = bus_generic_detach(dev);
747 if (error != 0)
748 return (error);
749
750 sc = device_get_softc(dev);
751 tegra_i2c_hw_init(sc);
752 if (sc->irq_h != NULL)
753 bus_teardown_intr(dev, sc->irq_res, sc->irq_h);
754 if (sc->irq_res != NULL)
755 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq_res);
756 if (sc->mem_res != NULL)
757 bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->mem_res);
758
759 LOCK_DESTROY(sc);
760 if (sc->iicbus)
761 device_delete_child(dev, sc->iicbus);
762 return (0);
763 }
764
765 static phandle_t
tegra_i2c_get_node(device_t bus,device_t dev)766 tegra_i2c_get_node(device_t bus, device_t dev)
767 {
768
769 /* Share controller node with iibus device. */
770 return (ofw_bus_get_node(bus));
771 }
772
773 static device_method_t tegra_i2c_methods[] = {
774 /* Device interface */
775 DEVMETHOD(device_probe, tegra_i2c_probe),
776 DEVMETHOD(device_attach, tegra_i2c_attach),
777 DEVMETHOD(device_detach, tegra_i2c_detach),
778
779 /* Bus interface */
780 DEVMETHOD(bus_setup_intr, bus_generic_setup_intr),
781 DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr),
782 DEVMETHOD(bus_alloc_resource, bus_generic_alloc_resource),
783 DEVMETHOD(bus_release_resource, bus_generic_release_resource),
784 DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
785 DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
786 DEVMETHOD(bus_adjust_resource, bus_generic_adjust_resource),
787 DEVMETHOD(bus_set_resource, bus_generic_rl_set_resource),
788 DEVMETHOD(bus_get_resource, bus_generic_rl_get_resource),
789
790 /* OFW methods */
791 DEVMETHOD(ofw_bus_get_node, tegra_i2c_get_node),
792
793 /* iicbus interface */
794 DEVMETHOD(iicbus_callback, iicbus_null_callback),
795 DEVMETHOD(iicbus_reset, tegra_i2c_iicbus_reset),
796 DEVMETHOD(iicbus_transfer, tegra_i2c_transfer),
797
798 DEVMETHOD_END
799 };
800
801 static DEFINE_CLASS_0(iichb, tegra_i2c_driver, tegra_i2c_methods,
802 sizeof(struct tegra_i2c_softc));
803 EARLY_DRIVER_MODULE(tegra_iic, simplebus, tegra_i2c_driver, NULL, NULL, 73);
804