]> git.sur5r.net Git - u-boot/blob - drivers/i2c/fti2c010.c
arm: mvebu: Disable L2 cache before enabling d-cache
[u-boot] / drivers / i2c / fti2c010.c
1 /*
2  * Faraday I2C Controller
3  *
4  * (C) Copyright 2010 Faraday Technology
5  * Dante Su <dantesu@faraday-tech.com>
6  *
7  * SPDX-License-Identifier:     GPL-2.0+
8  */
9
10 #include <common.h>
11 #include <asm/io.h>
12 #include <i2c.h>
13
14 #include "fti2c010.h"
15
16 #ifndef CONFIG_SYS_I2C_SPEED
17 #define CONFIG_SYS_I2C_SPEED    5000
18 #endif
19
20 #ifndef CONFIG_SYS_I2C_SLAVE
21 #define CONFIG_SYS_I2C_SLAVE    0
22 #endif
23
24 #ifndef CONFIG_FTI2C010_CLOCK
25 #define CONFIG_FTI2C010_CLOCK   clk_get_rate("I2C")
26 #endif
27
28 #ifndef CONFIG_FTI2C010_TIMEOUT
29 #define CONFIG_FTI2C010_TIMEOUT 10 /* ms */
30 #endif
31
32 /* 7-bit dev address + 1-bit read/write */
33 #define I2C_RD(dev)             ((((dev) << 1) & 0xfe) | 1)
34 #define I2C_WR(dev)             (((dev) << 1) & 0xfe)
35
36 struct fti2c010_chip {
37         struct fti2c010_regs *regs;
38 };
39
40 static struct fti2c010_chip chip_list[] = {
41         {
42                 .regs = (struct fti2c010_regs *)CONFIG_FTI2C010_BASE,
43         },
44 #ifdef CONFIG_FTI2C010_BASE1
45         {
46                 .regs = (struct fti2c010_regs *)CONFIG_FTI2C010_BASE1,
47         },
48 #endif
49 #ifdef CONFIG_FTI2C010_BASE2
50         {
51                 .regs = (struct fti2c010_regs *)CONFIG_FTI2C010_BASE2,
52         },
53 #endif
54 #ifdef CONFIG_FTI2C010_BASE3
55         {
56                 .regs = (struct fti2c010_regs *)CONFIG_FTI2C010_BASE3,
57         },
58 #endif
59 };
60
61 static int fti2c010_reset(struct fti2c010_chip *chip)
62 {
63         ulong ts;
64         int ret = -1;
65         struct fti2c010_regs *regs = chip->regs;
66
67         writel(CR_I2CRST, &regs->cr);
68         for (ts = get_timer(0); get_timer(ts) < CONFIG_FTI2C010_TIMEOUT; ) {
69                 if (!(readl(&regs->cr) & CR_I2CRST)) {
70                         ret = 0;
71                         break;
72                 }
73         }
74
75         if (ret)
76                 printf("fti2c010: reset timeout\n");
77
78         return ret;
79 }
80
81 static int fti2c010_wait(struct fti2c010_chip *chip, uint32_t mask)
82 {
83         int ret = -1;
84         uint32_t stat, ts;
85         struct fti2c010_regs *regs = chip->regs;
86
87         for (ts = get_timer(0); get_timer(ts) < CONFIG_FTI2C010_TIMEOUT; ) {
88                 stat = readl(&regs->sr);
89                 if ((stat & mask) == mask) {
90                         ret = 0;
91                         break;
92                 }
93         }
94
95         return ret;
96 }
97
98 static unsigned int set_i2c_bus_speed(struct fti2c010_chip *chip,
99         unsigned int speed)
100 {
101         struct fti2c010_regs *regs = chip->regs;
102         unsigned int clk = CONFIG_FTI2C010_CLOCK;
103         unsigned int gsr = 0;
104         unsigned int tsr = 32;
105         unsigned int div, rate;
106
107         for (div = 0; div < 0x3ffff; ++div) {
108                 /* SCLout = PCLK/(2*(COUNT + 2) + GSR) */
109                 rate = clk / (2 * (div + 2) + gsr);
110                 if (rate <= speed)
111                         break;
112         }
113
114         writel(TGSR_GSR(gsr) | TGSR_TSR(tsr), &regs->tgsr);
115         writel(CDR_DIV(div), &regs->cdr);
116
117         return rate;
118 }
119
120 /*
121  * Initialization, must be called once on start up, may be called
122  * repeatedly to change the speed and slave addresses.
123  */
124 static void fti2c010_init(struct i2c_adapter *adap, int speed, int slaveaddr)
125 {
126         struct fti2c010_chip *chip = chip_list + adap->hwadapnr;
127
128         if (adap->init_done)
129                 return;
130
131 #ifdef CONFIG_SYS_I2C_INIT_BOARD
132         /* Call board specific i2c bus reset routine before accessing the
133          * environment, which might be in a chip on that bus. For details
134          * about this problem see doc/I2C_Edge_Conditions.
135         */
136         i2c_init_board();
137 #endif
138
139         /* master init */
140
141         fti2c010_reset(chip);
142
143         set_i2c_bus_speed(chip, speed);
144
145         /* slave init, don't care */
146
147 #ifdef CONFIG_SYS_I2C_BOARD_LATE_INIT
148         /* Call board specific i2c bus reset routine AFTER the bus has been
149          * initialized. Use either this callpoint or i2c_init_board;
150          * which is called before fti2c010_init operations.
151          * For details about this problem see doc/I2C_Edge_Conditions.
152         */
153         i2c_board_late_init();
154 #endif
155 }
156
157 /*
158  * Probe the given I2C chip address.  Returns 0 if a chip responded,
159  * not 0 on failure.
160  */
161 static int fti2c010_probe(struct i2c_adapter *adap, u8 dev)
162 {
163         struct fti2c010_chip *chip = chip_list + adap->hwadapnr;
164         struct fti2c010_regs *regs = chip->regs;
165         int ret;
166
167         /* 1. Select slave device (7bits Address + 1bit R/W) */
168         writel(I2C_WR(dev), &regs->dr);
169         writel(CR_ENABLE | CR_TBEN | CR_START, &regs->cr);
170         ret = fti2c010_wait(chip, SR_DT);
171         if (ret)
172                 return ret;
173
174         /* 2. Select device register */
175         writel(0, &regs->dr);
176         writel(CR_ENABLE | CR_TBEN, &regs->cr);
177         ret = fti2c010_wait(chip, SR_DT);
178
179         return ret;
180 }
181
182 static void to_i2c_addr(u8 *buf, uint32_t addr, int alen)
183 {
184         int i, shift;
185
186         if (!buf || alen <= 0)
187                 return;
188
189         /* MSB first */
190         i = 0;
191         shift = (alen - 1) * 8;
192         while (alen-- > 0) {
193                 buf[i] = (u8)(addr >> shift);
194                 shift -= 8;
195         }
196 }
197
198 static int fti2c010_read(struct i2c_adapter *adap,
199                         u8 dev, uint addr, int alen, uchar *buf, int len)
200 {
201         struct fti2c010_chip *chip = chip_list + adap->hwadapnr;
202         struct fti2c010_regs *regs = chip->regs;
203         int ret, pos;
204         uchar paddr[4] = { 0 };
205
206         to_i2c_addr(paddr, addr, alen);
207
208         /*
209          * Phase A. Set register address
210          */
211
212         /* A.1 Select slave device (7bits Address + 1bit R/W) */
213         writel(I2C_WR(dev), &regs->dr);
214         writel(CR_ENABLE | CR_TBEN | CR_START, &regs->cr);
215         ret = fti2c010_wait(chip, SR_DT);
216         if (ret)
217                 return ret;
218
219         /* A.2 Select device register */
220         for (pos = 0; pos < alen; ++pos) {
221                 uint32_t ctrl = CR_ENABLE | CR_TBEN;
222
223                 writel(paddr[pos], &regs->dr);
224                 writel(ctrl, &regs->cr);
225                 ret = fti2c010_wait(chip, SR_DT);
226                 if (ret)
227                         return ret;
228         }
229
230         /*
231          * Phase B. Get register data
232          */
233
234         /* B.1 Select slave device (7bits Address + 1bit R/W) */
235         writel(I2C_RD(dev), &regs->dr);
236         writel(CR_ENABLE | CR_TBEN | CR_START, &regs->cr);
237         ret = fti2c010_wait(chip, SR_DT);
238         if (ret)
239                 return ret;
240
241         /* B.2 Get register data */
242         for (pos = 0; pos < len; ++pos) {
243                 uint32_t ctrl = CR_ENABLE | CR_TBEN;
244                 uint32_t stat = SR_DR;
245
246                 if (pos == len - 1) {
247                         ctrl |= CR_NAK | CR_STOP;
248                         stat |= SR_ACK;
249                 }
250                 writel(ctrl, &regs->cr);
251                 ret = fti2c010_wait(chip, stat);
252                 if (ret)
253                         break;
254                 buf[pos] = (uchar)(readl(&regs->dr) & 0xFF);
255         }
256
257         return ret;
258 }
259
260 static int fti2c010_write(struct i2c_adapter *adap,
261                         u8 dev, uint addr, int alen, u8 *buf, int len)
262 {
263         struct fti2c010_chip *chip = chip_list + adap->hwadapnr;
264         struct fti2c010_regs *regs = chip->regs;
265         int ret, pos;
266         uchar paddr[4] = { 0 };
267
268         to_i2c_addr(paddr, addr, alen);
269
270         /*
271          * Phase A. Set register address
272          *
273          * A.1 Select slave device (7bits Address + 1bit R/W)
274          */
275         writel(I2C_WR(dev), &regs->dr);
276         writel(CR_ENABLE | CR_TBEN | CR_START, &regs->cr);
277         ret = fti2c010_wait(chip, SR_DT);
278         if (ret)
279                 return ret;
280
281         /* A.2 Select device register */
282         for (pos = 0; pos < alen; ++pos) {
283                 uint32_t ctrl = CR_ENABLE | CR_TBEN;
284
285                 writel(paddr[pos], &regs->dr);
286                 writel(ctrl, &regs->cr);
287                 ret = fti2c010_wait(chip, SR_DT);
288                 if (ret)
289                         return ret;
290         }
291
292         /*
293          * Phase B. Set register data
294          */
295         for (pos = 0; pos < len; ++pos) {
296                 uint32_t ctrl = CR_ENABLE | CR_TBEN;
297
298                 if (pos == len - 1)
299                         ctrl |= CR_STOP;
300                 writel(buf[pos], &regs->dr);
301                 writel(ctrl, &regs->cr);
302                 ret = fti2c010_wait(chip, SR_DT);
303                 if (ret)
304                         break;
305         }
306
307         return ret;
308 }
309
310 static unsigned int fti2c010_set_bus_speed(struct i2c_adapter *adap,
311                         unsigned int speed)
312 {
313         struct fti2c010_chip *chip = chip_list + adap->hwadapnr;
314         int ret;
315
316         fti2c010_reset(chip);
317         ret = set_i2c_bus_speed(chip, speed);
318
319         return ret;
320 }
321
322 /*
323  * Register i2c adapters
324  */
325 U_BOOT_I2C_ADAP_COMPLETE(i2c_0, fti2c010_init, fti2c010_probe, fti2c010_read,
326                         fti2c010_write, fti2c010_set_bus_speed,
327                         CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE,
328                         0)
329 #ifdef CONFIG_FTI2C010_BASE1
330 U_BOOT_I2C_ADAP_COMPLETE(i2c_1, fti2c010_init, fti2c010_probe, fti2c010_read,
331                         fti2c010_write, fti2c010_set_bus_speed,
332                         CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE,
333                         1)
334 #endif
335 #ifdef CONFIG_FTI2C010_BASE2
336 U_BOOT_I2C_ADAP_COMPLETE(i2c_2, fti2c010_init, fti2c010_probe, fti2c010_read,
337                         fti2c010_write, fti2c010_set_bus_speed,
338                         CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE,
339                         2)
340 #endif
341 #ifdef CONFIG_FTI2C010_BASE3
342 U_BOOT_I2C_ADAP_COMPLETE(i2c_3, fti2c010_init, fti2c010_probe, fti2c010_read,
343                         fti2c010_write, fti2c010_set_bus_speed,
344                         CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE,
345                         3)
346 #endif