← Back to branch summary

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

« back to all changes in this revision

Viewing changes to roms/u-boot/drivers/i2c/mxc_i2c.c

  • Committer: Phil Dennis-Jordan
  • Date: 2017-07-21 08:03:43 UTC
  • mfrom: (1.1.1)
  • Revision ID: phil@philjordan.eu-20170721080343-2yr2vdj7713czahv
New upstream release 2.9.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
roms/u-boot/drivers/i2c/mxc_i2c.c
 
1
/*
 
2
 * i2c driver for Freescale i.MX series
 
3
 *
 
4
 * (c) 2007 Pengutronix, Sascha Hauer <s.hauer@pengutronix.de>
 
5
 * (c) 2011 Marek Vasut <marek.vasut@gmail.com>
 
6
 *
 
7
 * Based on i2c-imx.c from linux kernel:
 
8
 *  Copyright (C) 2005 Torsten Koschorrek <koschorrek at synertronixx.de>
 
9
 *  Copyright (C) 2005 Matthias Blaschke <blaschke at synertronixx.de>
 
10
 *  Copyright (C) 2007 RightHand Technologies, Inc.
 
11
 *  Copyright (C) 2008 Darius Augulis <darius.augulis at teltonika.lt>
 
12
 *
 
13
 *
 
14
 * SPDX-License-Identifier:     GPL-2.0+
 
15
 */
 
16
 
 
17
#include <common.h>
 
18
#include <asm/arch/clock.h>
 
19
#include <asm/arch/imx-regs.h>
 
20
#include <asm/errno.h>
 
21
#include <asm/io.h>
 
22
#include <i2c.h>
 
23
#include <watchdog.h>
 
24
 
 
25
DECLARE_GLOBAL_DATA_PTR;
 
26
 
 
27
#ifdef I2C_QUIRK_REG
 
28
struct mxc_i2c_regs {
 
29
        uint8_t         iadr;
 
30
        uint8_t         ifdr;
 
31
        uint8_t         i2cr;
 
32
        uint8_t         i2sr;
 
33
        uint8_t         i2dr;
 
34
};
 
35
#else
 
36
struct mxc_i2c_regs {
 
37
        uint32_t        iadr;
 
38
        uint32_t        ifdr;
 
39
        uint32_t        i2cr;
 
40
        uint32_t        i2sr;
 
41
        uint32_t        i2dr;
 
42
};
 
43
#endif
 
44
 
 
45
#define I2CR_IIEN       (1 << 6)
 
46
#define I2CR_MSTA       (1 << 5)
 
47
#define I2CR_MTX        (1 << 4)
 
48
#define I2CR_TX_NO_AK   (1 << 3)
 
49
#define I2CR_RSTA       (1 << 2)
 
50
 
 
51
#define I2SR_ICF        (1 << 7)
 
52
#define I2SR_IBB        (1 << 5)
 
53
#define I2SR_IAL        (1 << 4)
 
54
#define I2SR_IIF        (1 << 1)
 
55
#define I2SR_RX_NO_AK   (1 << 0)
 
56
 
 
57
#ifdef I2C_QUIRK_REG
 
58
#define I2CR_IEN        (0 << 7)
 
59
#define I2CR_IDIS       (1 << 7)
 
60
#define I2SR_IIF_CLEAR  (1 << 1)
 
61
#else
 
62
#define I2CR_IEN        (1 << 7)
 
63
#define I2CR_IDIS       (0 << 7)
 
64
#define I2SR_IIF_CLEAR  (0 << 1)
 
65
#endif
 
66
 
 
67
#if defined(CONFIG_HARD_I2C) && !defined(CONFIG_SYS_I2C_BASE)
 
68
#error "define CONFIG_SYS_I2C_BASE to use the mxc_i2c driver"
 
69
#endif
 
70
 
 
71
#ifdef I2C_QUIRK_REG
 
72
static u16 i2c_clk_div[60][2] = {
 
73
        { 20,   0x00 }, { 22,   0x01 }, { 24,   0x02 }, { 26,   0x03 },
 
74
        { 28,   0x04 }, { 30,   0x05 }, { 32,   0x09 }, { 34,   0x06 },
 
75
        { 36,   0x0A }, { 40,   0x07 }, { 44,   0x0C }, { 48,   0x0D },
 
76
        { 52,   0x43 }, { 56,   0x0E }, { 60,   0x45 }, { 64,   0x12 },
 
77
        { 68,   0x0F }, { 72,   0x13 }, { 80,   0x14 }, { 88,   0x15 },
 
78
        { 96,   0x19 }, { 104,  0x16 }, { 112,  0x1A }, { 128,  0x17 },
 
79
        { 136,  0x4F }, { 144,  0x1C }, { 160,  0x1D }, { 176,  0x55 },
 
80
        { 192,  0x1E }, { 208,  0x56 }, { 224,  0x22 }, { 228,  0x24 },
 
81
        { 240,  0x1F }, { 256,  0x23 }, { 288,  0x5C }, { 320,  0x25 },
 
82
        { 384,  0x26 }, { 448,  0x2A }, { 480,  0x27 }, { 512,  0x2B },
 
83
        { 576,  0x2C }, { 640,  0x2D }, { 768,  0x31 }, { 896,  0x32 },
 
84
        { 960,  0x2F }, { 1024, 0x33 }, { 1152, 0x34 }, { 1280, 0x35 },
 
85
        { 1536, 0x36 }, { 1792, 0x3A }, { 1920, 0x37 }, { 2048, 0x3B },
 
86
        { 2304, 0x3C }, { 2560, 0x3D }, { 3072, 0x3E }, { 3584, 0x7A },
 
87
        { 3840, 0x3F }, { 4096, 0x7B }, { 5120, 0x7D }, { 6144, 0x7E },
 
88
};
 
89
#else
 
90
static u16 i2c_clk_div[50][2] = {
 
91
        { 22,   0x20 }, { 24,   0x21 }, { 26,   0x22 }, { 28,   0x23 },
 
92
        { 30,   0x00 }, { 32,   0x24 }, { 36,   0x25 }, { 40,   0x26 },
 
93
        { 42,   0x03 }, { 44,   0x27 }, { 48,   0x28 }, { 52,   0x05 },
 
94
        { 56,   0x29 }, { 60,   0x06 }, { 64,   0x2A }, { 72,   0x2B },
 
95
        { 80,   0x2C }, { 88,   0x09 }, { 96,   0x2D }, { 104,  0x0A },
 
96
        { 112,  0x2E }, { 128,  0x2F }, { 144,  0x0C }, { 160,  0x30 },
 
97
        { 192,  0x31 }, { 224,  0x32 }, { 240,  0x0F }, { 256,  0x33 },
 
98
        { 288,  0x10 }, { 320,  0x34 }, { 384,  0x35 }, { 448,  0x36 },
 
99
        { 480,  0x13 }, { 512,  0x37 }, { 576,  0x14 }, { 640,  0x38 },
 
100
        { 768,  0x39 }, { 896,  0x3A }, { 960,  0x17 }, { 1024, 0x3B },
 
101
        { 1152, 0x18 }, { 1280, 0x3C }, { 1536, 0x3D }, { 1792, 0x3E },
 
102
        { 1920, 0x1B }, { 2048, 0x3F }, { 2304, 0x1C }, { 2560, 0x1D },
 
103
        { 3072, 0x1E }, { 3840, 0x1F }
 
104
};
 
105
#endif
 
106
 
 
107
 
 
108
#ifndef CONFIG_SYS_MXC_I2C1_SPEED
 
109
#define CONFIG_SYS_MXC_I2C1_SPEED 100000
 
110
#endif
 
111
#ifndef CONFIG_SYS_MXC_I2C2_SPEED
 
112
#define CONFIG_SYS_MXC_I2C2_SPEED 100000
 
113
#endif
 
114
#ifndef CONFIG_SYS_MXC_I2C3_SPEED
 
115
#define CONFIG_SYS_MXC_I2C3_SPEED 100000
 
116
#endif
 
117
 
 
118
#ifndef CONFIG_SYS_MXC_I2C1_SLAVE
 
119
#define CONFIG_SYS_MXC_I2C1_SLAVE 0
 
120
#endif
 
121
#ifndef CONFIG_SYS_MXC_I2C2_SLAVE
 
122
#define CONFIG_SYS_MXC_I2C2_SLAVE 0
 
123
#endif
 
124
#ifndef CONFIG_SYS_MXC_I2C3_SLAVE
 
125
#define CONFIG_SYS_MXC_I2C3_SLAVE 0
 
126
#endif
 
127
 
 
128
 
 
129
/*
 
130
 * Calculate and set proper clock divider
 
131
 */
 
132
static uint8_t i2c_imx_get_clk(unsigned int rate)
 
133
{
 
134
        unsigned int i2c_clk_rate;
 
135
        unsigned int div;
 
136
        u8 clk_div;
 
137
 
 
138
#if defined(CONFIG_MX31)
 
139
        struct clock_control_regs *sc_regs =
 
140
                (struct clock_control_regs *)CCM_BASE;
 
141
 
 
142
        /* start the required I2C clock */
 
143
        writel(readl(&sc_regs->cgr0) | (3 << CONFIG_SYS_I2C_CLK_OFFSET),
 
144
                &sc_regs->cgr0);
 
145
#endif
 
146
 
 
147
        /* Divider value calculation */
 
148
        i2c_clk_rate = mxc_get_clock(MXC_I2C_CLK);
 
149
        div = (i2c_clk_rate + rate - 1) / rate;
 
150
        if (div < i2c_clk_div[0][0])
 
151
                clk_div = 0;
 
152
        else if (div > i2c_clk_div[ARRAY_SIZE(i2c_clk_div) - 1][0])
 
153
                clk_div = ARRAY_SIZE(i2c_clk_div) - 1;
 
154
        else
 
155
                for (clk_div = 0; i2c_clk_div[clk_div][0] < div; clk_div++)
 
156
                        ;
 
157
 
 
158
        /* Store divider value */
 
159
        return clk_div;
 
160
}
 
161
 
 
162
/*
 
163
 * Set I2C Bus speed
 
164
 */
 
165
static int bus_i2c_set_bus_speed(void *base, int speed)
 
166
{
 
167
        struct mxc_i2c_regs *i2c_regs = (struct mxc_i2c_regs *)base;
 
168
        u8 clk_idx = i2c_imx_get_clk(speed);
 
169
        u8 idx = i2c_clk_div[clk_idx][1];
 
170
 
 
171
        /* Store divider value */
 
172
        writeb(idx, &i2c_regs->ifdr);
 
173
 
 
174
        /* Reset module */
 
175
        writeb(I2CR_IDIS, &i2c_regs->i2cr);
 
176
        writeb(0, &i2c_regs->i2sr);
 
177
        return 0;
 
178
}
 
179
 
 
180
#define ST_BUS_IDLE (0 | (I2SR_IBB << 8))
 
181
#define ST_BUS_BUSY (I2SR_IBB | (I2SR_IBB << 8))
 
182
#define ST_IIF (I2SR_IIF | (I2SR_IIF << 8))
 
183
 
 
184
static int wait_for_sr_state(struct mxc_i2c_regs *i2c_regs, unsigned state)
 
185
{
 
186
        unsigned sr;
 
187
        ulong elapsed;
 
188
        ulong start_time = get_timer(0);
 
189
        for (;;) {
 
190
                sr = readb(&i2c_regs->i2sr);
 
191
                if (sr & I2SR_IAL) {
 
192
#ifdef I2C_QUIRK_REG
 
193
                        writeb(sr | I2SR_IAL, &i2c_regs->i2sr);
 
194
#else
 
195
                        writeb(sr & ~I2SR_IAL, &i2c_regs->i2sr);
 
196
#endif
 
197
                        printf("%s: Arbitration lost sr=%x cr=%x state=%x\n",
 
198
                                __func__, sr, readb(&i2c_regs->i2cr), state);
 
199
                        return -ERESTART;
 
200
                }
 
201
                if ((sr & (state >> 8)) == (unsigned char)state)
 
202
                        return sr;
 
203
                WATCHDOG_RESET();
 
204
                elapsed = get_timer(start_time);
 
205
                if (elapsed > (CONFIG_SYS_HZ / 10))     /* .1 seconds */
 
206
                        break;
 
207
        }
 
208
        printf("%s: failed sr=%x cr=%x state=%x\n", __func__,
 
209
                        sr, readb(&i2c_regs->i2cr), state);
 
210
        return -ETIMEDOUT;
 
211
}
 
212
 
 
213
static int tx_byte(struct mxc_i2c_regs *i2c_regs, u8 byte)
 
214
{
 
215
        int ret;
 
216
 
 
217
        writeb(I2SR_IIF_CLEAR, &i2c_regs->i2sr);
 
218
        writeb(byte, &i2c_regs->i2dr);
 
219
        ret = wait_for_sr_state(i2c_regs, ST_IIF);
 
220
        if (ret < 0)
 
221
                return ret;
 
222
        if (ret & I2SR_RX_NO_AK)
 
223
                return -ENODEV;
 
224
        return 0;
 
225
}
 
226
 
 
227
/*
 
228
 * Stop I2C transaction
 
229
 */
 
230
static void i2c_imx_stop(struct mxc_i2c_regs *i2c_regs)
 
231
{
 
232
        int ret;
 
233
        unsigned int temp = readb(&i2c_regs->i2cr);
 
234
 
 
235
        temp &= ~(I2CR_MSTA | I2CR_MTX);
 
236
        writeb(temp, &i2c_regs->i2cr);
 
237
        ret = wait_for_sr_state(i2c_regs, ST_BUS_IDLE);
 
238
        if (ret < 0)
 
239
                printf("%s:trigger stop failed\n", __func__);
 
240
}
 
241
 
 
242
/*
 
243
 * Send start signal, chip address and
 
244
 * write register address
 
245
 */
 
246
static int i2c_init_transfer_(struct mxc_i2c_regs *i2c_regs,
 
247
                uchar chip, uint addr, int alen)
 
248
{
 
249
        unsigned int temp;
 
250
        int ret;
 
251
 
 
252
        /* Enable I2C controller */
 
253
#ifdef I2C_QUIRK_REG
 
254
        if (readb(&i2c_regs->i2cr) & I2CR_IDIS) {
 
255
#else
 
256
        if (!(readb(&i2c_regs->i2cr) & I2CR_IEN)) {
 
257
#endif
 
258
                writeb(I2CR_IEN, &i2c_regs->i2cr);
 
259
                /* Wait for controller to be stable */
 
260
                udelay(50);
 
261
        }
 
262
        if (readb(&i2c_regs->iadr) == (chip << 1))
 
263
                writeb((chip << 1) ^ 2, &i2c_regs->iadr);
 
264
        writeb(I2SR_IIF_CLEAR, &i2c_regs->i2sr);
 
265
        ret = wait_for_sr_state(i2c_regs, ST_BUS_IDLE);
 
266
        if (ret < 0)
 
267
                return ret;
 
268
 
 
269
        /* Start I2C transaction */
 
270
        temp = readb(&i2c_regs->i2cr);
 
271
        temp |= I2CR_MSTA;
 
272
        writeb(temp, &i2c_regs->i2cr);
 
273
 
 
274
        ret = wait_for_sr_state(i2c_regs, ST_BUS_BUSY);
 
275
        if (ret < 0)
 
276
                return ret;
 
277
 
 
278
        temp |= I2CR_MTX | I2CR_TX_NO_AK;
 
279
        writeb(temp, &i2c_regs->i2cr);
 
280
 
 
281
        /* write slave address */
 
282
        ret = tx_byte(i2c_regs, chip << 1);
 
283
        if (ret < 0)
 
284
                return ret;
 
285
 
 
286
        while (alen--) {
 
287
                ret = tx_byte(i2c_regs, (addr >> (alen * 8)) & 0xff);
 
288
                if (ret < 0)
 
289
                        return ret;
 
290
        }
 
291
        return 0;
 
292
}
 
293
 
 
294
static int i2c_idle_bus(void *base);
 
295
 
 
296
static int i2c_init_transfer(struct mxc_i2c_regs *i2c_regs,
 
297
                uchar chip, uint addr, int alen)
 
298
{
 
299
        int retry;
 
300
        int ret;
 
301
        for (retry = 0; retry < 3; retry++) {
 
302
                ret = i2c_init_transfer_(i2c_regs, chip, addr, alen);
 
303
                if (ret >= 0)
 
304
                        return 0;
 
305
                i2c_imx_stop(i2c_regs);
 
306
                if (ret == -ENODEV)
 
307
                        return ret;
 
308
 
 
309
                printf("%s: failed for chip 0x%x retry=%d\n", __func__, chip,
 
310
                                retry);
 
311
                if (ret != -ERESTART)
 
312
                        /* Disable controller */
 
313
                        writeb(I2CR_IDIS, &i2c_regs->i2cr);
 
314
                udelay(100);
 
315
                if (i2c_idle_bus(i2c_regs) < 0)
 
316
                        break;
 
317
        }
 
318
        printf("%s: give up i2c_regs=%p\n", __func__, i2c_regs);
 
319
        return ret;
 
320
}
 
321
 
 
322
/*
 
323
 * Read data from I2C device
 
324
 */
 
325
int bus_i2c_read(void *base, uchar chip, uint addr, int alen, uchar *buf,
 
326
                int len)
 
327
{
 
328
        int ret;
 
329
        unsigned int temp;
 
330
        int i;
 
331
        struct mxc_i2c_regs *i2c_regs = (struct mxc_i2c_regs *)base;
 
332
 
 
333
        ret = i2c_init_transfer(i2c_regs, chip, addr, alen);
 
334
        if (ret < 0)
 
335
                return ret;
 
336
 
 
337
        temp = readb(&i2c_regs->i2cr);
 
338
        temp |= I2CR_RSTA;
 
339
        writeb(temp, &i2c_regs->i2cr);
 
340
 
 
341
        ret = tx_byte(i2c_regs, (chip << 1) | 1);
 
342
        if (ret < 0) {
 
343
                i2c_imx_stop(i2c_regs);
 
344
                return ret;
 
345
        }
 
346
 
 
347
        /* setup bus to read data */
 
348
        temp = readb(&i2c_regs->i2cr);
 
349
        temp &= ~(I2CR_MTX | I2CR_TX_NO_AK);
 
350
        if (len == 1)
 
351
                temp |= I2CR_TX_NO_AK;
 
352
        writeb(temp, &i2c_regs->i2cr);
 
353
        writeb(I2SR_IIF_CLEAR, &i2c_regs->i2sr);
 
354
        readb(&i2c_regs->i2dr);         /* dummy read to clear ICF */
 
355
 
 
356
        /* read data */
 
357
        for (i = 0; i < len; i++) {
 
358
                ret = wait_for_sr_state(i2c_regs, ST_IIF);
 
359
                if (ret < 0) {
 
360
                        i2c_imx_stop(i2c_regs);
 
361
                        return ret;
 
362
                }
 
363
 
 
364
                /*
 
365
                 * It must generate STOP before read I2DR to prevent
 
366
                 * controller from generating another clock cycle
 
367
                 */
 
368
                if (i == (len - 1)) {
 
369
                        i2c_imx_stop(i2c_regs);
 
370
                } else if (i == (len - 2)) {
 
371
                        temp = readb(&i2c_regs->i2cr);
 
372
                        temp |= I2CR_TX_NO_AK;
 
373
                        writeb(temp, &i2c_regs->i2cr);
 
374
                }
 
375
                writeb(I2SR_IIF_CLEAR, &i2c_regs->i2sr);
 
376
                buf[i] = readb(&i2c_regs->i2dr);
 
377
        }
 
378
        i2c_imx_stop(i2c_regs);
 
379
        return 0;
 
380
}
 
381
 
 
382
/*
 
383
 * Write data to I2C device
 
384
 */
 
385
int bus_i2c_write(void *base, uchar chip, uint addr, int alen,
 
386
                const uchar *buf, int len)
 
387
{
 
388
        int ret;
 
389
        int i;
 
390
        struct mxc_i2c_regs *i2c_regs = (struct mxc_i2c_regs *)base;
 
391
 
 
392
        ret = i2c_init_transfer(i2c_regs, chip, addr, alen);
 
393
        if (ret < 0)
 
394
                return ret;
 
395
 
 
396
        for (i = 0; i < len; i++) {
 
397
                ret = tx_byte(i2c_regs, buf[i]);
 
398
                if (ret < 0)
 
399
                        break;
 
400
        }
 
401
        i2c_imx_stop(i2c_regs);
 
402
        return ret;
 
403
}
 
404
 
 
405
struct i2c_parms {
 
406
        void *base;
 
407
        void *idle_bus_data;
 
408
        int (*idle_bus_fn)(void *p);
 
409
};
 
410
 
 
411
struct sram_data {
 
412
        unsigned curr_i2c_bus;
 
413
        struct i2c_parms i2c_data[3];
 
414
};
 
415
 
 
416
static void * const i2c_bases[] = {
 
417
#if defined(CONFIG_MX25)
 
418
        (void *)IMX_I2C_BASE,
 
419
        (void *)IMX_I2C2_BASE,
 
420
        (void *)IMX_I2C3_BASE
 
421
#elif defined(CONFIG_MX27)
 
422
        (void *)IMX_I2C1_BASE,
 
423
        (void *)IMX_I2C2_BASE
 
424
#elif defined(CONFIG_MX31) || defined(CONFIG_MX35) || \
 
425
        defined(CONFIG_MX51) || defined(CONFIG_MX53) || \
 
426
        defined(CONFIG_MX6)
 
427
        (void *)I2C1_BASE_ADDR,
 
428
        (void *)I2C2_BASE_ADDR,
 
429
        (void *)I2C3_BASE_ADDR
 
430
#elif defined(CONFIG_VF610)
 
431
        (void *)I2C0_BASE_ADDR
 
432
#else
 
433
#error "architecture not supported"
 
434
#endif
 
435
};
 
436
 
 
437
void *i2c_get_base(struct i2c_adapter *adap)
 
438
{
 
439
        return i2c_bases[adap->hwadapnr];
 
440
}
 
441
 
 
442
static struct i2c_parms *i2c_get_parms(void *base)
 
443
{
 
444
        struct sram_data *srdata = (void *)gd->srdata;
 
445
        int i = 0;
 
446
        struct i2c_parms *p = srdata->i2c_data;
 
447
        while (i < ARRAY_SIZE(srdata->i2c_data)) {
 
448
                if (p->base == base)
 
449
                        return p;
 
450
                p++;
 
451
                i++;
 
452
        }
 
453
        printf("Invalid I2C base: %p\n", base);
 
454
        return NULL;
 
455
}
 
456
 
 
457
static int i2c_idle_bus(void *base)
 
458
{
 
459
        struct i2c_parms *p = i2c_get_parms(base);
 
460
        if (p && p->idle_bus_fn)
 
461
                return p->idle_bus_fn(p->idle_bus_data);
 
462
        return 0;
 
463
}
 
464
 
 
465
static int mxc_i2c_read(struct i2c_adapter *adap, uint8_t chip,
 
466
                                uint addr, int alen, uint8_t *buffer,
 
467
                                int len)
 
468
{
 
469
        return bus_i2c_read(i2c_get_base(adap), chip, addr, alen, buffer, len);
 
470
}
 
471
 
 
472
static int mxc_i2c_write(struct i2c_adapter *adap, uint8_t chip,
 
473
                                uint addr, int alen, uint8_t *buffer,
 
474
                                int len)
 
475
{
 
476
        return bus_i2c_write(i2c_get_base(adap), chip, addr, alen, buffer, len);
 
477
}
 
478
 
 
479
/*
 
480
 * Test if a chip at a given address responds (probe the chip)
 
481
 */
 
482
static int mxc_i2c_probe(struct i2c_adapter *adap, uint8_t chip)
 
483
{
 
484
        return bus_i2c_write(i2c_get_base(adap), chip, 0, 0, NULL, 0);
 
485
}
 
486
 
 
487
void bus_i2c_init(void *base, int speed, int unused,
 
488
                int (*idle_bus_fn)(void *p), void *idle_bus_data)
 
489
{
 
490
        struct sram_data *srdata = (void *)gd->srdata;
 
491
        int i = 0;
 
492
        struct i2c_parms *p = srdata->i2c_data;
 
493
        if (!base)
 
494
                return;
 
495
        for (;;) {
 
496
                if (!p->base || (p->base == base)) {
 
497
                        p->base = base;
 
498
                        if (idle_bus_fn) {
 
499
                                p->idle_bus_fn = idle_bus_fn;
 
500
                                p->idle_bus_data = idle_bus_data;
 
501
                        }
 
502
                        break;
 
503
                }
 
504
                p++;
 
505
                i++;
 
506
                if (i >= ARRAY_SIZE(srdata->i2c_data))
 
507
                        return;
 
508
        }
 
509
        bus_i2c_set_bus_speed(base, speed);
 
510
}
 
511
 
 
512
/*
 
513
 * Init I2C Bus
 
514
 */
 
515
static void mxc_i2c_init(struct i2c_adapter *adap, int speed, int slaveaddr)
 
516
{
 
517
        bus_i2c_init(i2c_get_base(adap), speed, slaveaddr, NULL, NULL);
 
518
}
 
519
 
 
520
/*
 
521
 * Set I2C Speed
 
522
 */
 
523
static uint mxc_i2c_set_bus_speed(struct i2c_adapter *adap, uint speed)
 
524
{
 
525
        return bus_i2c_set_bus_speed(i2c_get_base(adap), speed);
 
526
}
 
527
 
 
528
/*
 
529
 * Register mxc i2c adapters
 
530
 */
 
531
U_BOOT_I2C_ADAP_COMPLETE(mxc0, mxc_i2c_init, mxc_i2c_probe,
 
532
                         mxc_i2c_read, mxc_i2c_write,
 
533
                         mxc_i2c_set_bus_speed,
 
534
                         CONFIG_SYS_MXC_I2C1_SPEED,
 
535
                         CONFIG_SYS_MXC_I2C1_SLAVE, 0)
 
536
U_BOOT_I2C_ADAP_COMPLETE(mxc1, mxc_i2c_init, mxc_i2c_probe,
 
537
                         mxc_i2c_read, mxc_i2c_write,
 
538
                         mxc_i2c_set_bus_speed,
 
539
                         CONFIG_SYS_MXC_I2C2_SPEED,
 
540
                         CONFIG_SYS_MXC_I2C2_SLAVE, 1)
 
541
#if defined(CONFIG_MX31) || defined(CONFIG_MX35) ||\
 
542
        defined(CONFIG_MX51) || defined(CONFIG_MX53) ||\
 
543
        defined(CONFIG_MX6)
 
544
U_BOOT_I2C_ADAP_COMPLETE(mxc2, mxc_i2c_init, mxc_i2c_probe,
 
545
                         mxc_i2c_read, mxc_i2c_write,
 
546
                         mxc_i2c_set_bus_speed,
 
547
                         CONFIG_SYS_MXC_I2C3_SPEED,
 
548
                         CONFIG_SYS_MXC_I2C3_SLAVE, 2)
 
549
#endif