i2c: mvtwsi: Fix order of address bytes (high to low)
[platform/kernel/u-boot.git] / drivers / i2c / mvtwsi.c
1 /*
2  * Driver for the TWSI (i2c) controller found on the Marvell
3  * orion5x and kirkwood SoC families.
4  *
5  * Author: Albert Aribaud <albert.u.boot@aribaud.net>
6  * Copyright (c) 2010 Albert Aribaud.
7  *
8  * SPDX-License-Identifier:     GPL-2.0+
9  */
10
11 #include <common.h>
12 #include <i2c.h>
13 #include <asm/errno.h>
14 #include <asm/io.h>
15 #include <linux/compat.h>
16 #ifdef CONFIG_DM_I2C
17 #include <dm.h>
18 #endif
19
20 DECLARE_GLOBAL_DATA_PTR;
21
22 /*
23  * Include a file that will provide CONFIG_I2C_MVTWSI_BASE*, and possibly other
24  * settings
25  */
26
27 #ifndef CONFIG_DM_I2C
28 #if defined(CONFIG_ORION5X)
29 #include <asm/arch/orion5x.h>
30 #elif (defined(CONFIG_KIRKWOOD) || defined(CONFIG_ARCH_MVEBU))
31 #include <asm/arch/soc.h>
32 #elif defined(CONFIG_SUNXI)
33 #include <asm/arch/i2c.h>
34 #else
35 #error Driver mvtwsi not supported by SoC or board
36 #endif
37 #endif /* CONFIG_DM_I2C */
38
39 /*
40  * TWSI register structure
41  */
42
43 #ifdef CONFIG_SUNXI
44
45 struct  mvtwsi_registers {
46         u32 slave_address;
47         u32 xtnd_slave_addr;
48         u32 data;
49         u32 control;
50         u32 status;
51         u32 baudrate;
52         u32 soft_reset;
53 };
54
55 #else
56
57 struct  mvtwsi_registers {
58         u32 slave_address;
59         u32 data;
60         u32 control;
61         union {
62                 u32 status;     /* When reading */
63                 u32 baudrate;   /* When writing */
64         };
65         u32 xtnd_slave_addr;
66         u32 reserved[2];
67         u32 soft_reset;
68 };
69
70 #endif
71
72 #ifdef CONFIG_DM_I2C
73 struct mvtwsi_i2c_dev {
74         /* TWSI Register base for the device */
75         struct mvtwsi_registers *base;
76         /* Number of the device (determined from cell-index property) */
77         int index;
78         /* The I2C slave address for the device */
79         u8 slaveadd;
80         /* The configured I2C speed in Hz */
81         uint speed;
82         /* The current length of a clock period (depending on speed) */
83         uint tick;
84 };
85 #endif /* CONFIG_DM_I2C */
86
87 /*
88  * enum mvtwsi_ctrl_register_fields - Bit masks for flags in the control
89  * register
90  */
91 enum mvtwsi_ctrl_register_fields {
92         /* Acknowledge bit */
93         MVTWSI_CONTROL_ACK      = 0x00000004,
94         /* Interrupt flag */
95         MVTWSI_CONTROL_IFLG     = 0x00000008,
96         /* Stop bit */
97         MVTWSI_CONTROL_STOP     = 0x00000010,
98         /* Start bit */
99         MVTWSI_CONTROL_START    = 0x00000020,
100         /* I2C enable */
101         MVTWSI_CONTROL_TWSIEN   = 0x00000040,
102         /* Interrupt enable */
103         MVTWSI_CONTROL_INTEN    = 0x00000080,
104 };
105
106 /*
107  * On sun6i and newer, IFLG is a write-clear bit, which is cleared by writing 1;
108  * on other platforms, it is a normal r/w bit, which is cleared by writing 0.
109  */
110
111 #ifdef CONFIG_SUNXI_GEN_SUN6I
112 #define MVTWSI_CONTROL_CLEAR_IFLG       0x00000008
113 #else
114 #define MVTWSI_CONTROL_CLEAR_IFLG       0x00000000
115 #endif
116
117 /*
118  * enum mvstwsi_status_values - Possible values of I2C controller's status
119  * register
120  *
121  * Only those statuses expected in normal master operation on
122  * non-10-bit-address devices are specified.
123  *
124  * Every status that's unexpected during normal operation (bus errors,
125  * arbitration losses, missing ACKs...) is passed back to the caller as an error
126  * code.
127  */
128 enum mvstwsi_status_values {
129         /* START condition transmitted */
130         MVTWSI_STATUS_START             = 0x08,
131         /* Repeated START condition transmitted */
132         MVTWSI_STATUS_REPEATED_START    = 0x10,
133         /* Address + write bit transmitted, ACK received */
134         MVTWSI_STATUS_ADDR_W_ACK        = 0x18,
135         /* Data transmitted, ACK received */
136         MVTWSI_STATUS_DATA_W_ACK        = 0x28,
137         /* Address + read bit transmitted, ACK received */
138         MVTWSI_STATUS_ADDR_R_ACK        = 0x40,
139         /* Address + read bit transmitted, ACK not received */
140         MVTWSI_STATUS_ADDR_R_NAK        = 0x48,
141         /* Data received, ACK transmitted */
142         MVTWSI_STATUS_DATA_R_ACK        = 0x50,
143         /* Data received, ACK not transmitted */
144         MVTWSI_STATUS_DATA_R_NAK        = 0x58,
145         /* No relevant status */
146         MVTWSI_STATUS_IDLE              = 0xF8,
147 };
148
149 /*
150  * enum mvstwsi_ack_flags - Determine whether a read byte should be
151  * acknowledged or not.
152  */
153 enum mvtwsi_ack_flags {
154         /* Send NAK after received byte */
155         MVTWSI_READ_NAK = 0,
156         /* Send ACK after received byte */
157         MVTWSI_READ_ACK = 1,
158 };
159
160 /*
161  * calc_tick() - Calculate the duration of a clock cycle from the I2C speed
162  *
163  * @speed:      The speed in Hz to calculate the clock cycle duration for.
164  * @return The duration of a clock cycle in ns.
165  */
166 inline uint calc_tick(uint speed)
167 {
168         /* One tick = the duration of a period at the specified speed in ns (we
169          * add 100 ns to be on the safe side) */
170         return (1000000000u / speed) + 100;
171 }
172
173 #ifndef CONFIG_DM_I2C
174
175 /*
176  * twsi_get_base() - Get controller register base for specified adapter
177  *
178  * @adap:       Adapter to get the register base for.
179  * @return Register base for the specified adapter.
180  */
181 static struct mvtwsi_registers *twsi_get_base(struct i2c_adapter *adap)
182 {
183         switch (adap->hwadapnr) {
184 #ifdef CONFIG_I2C_MVTWSI_BASE0
185         case 0:
186                 return (struct mvtwsi_registers *)CONFIG_I2C_MVTWSI_BASE0;
187 #endif
188 #ifdef CONFIG_I2C_MVTWSI_BASE1
189         case 1:
190                 return (struct mvtwsi_registers *)CONFIG_I2C_MVTWSI_BASE1;
191 #endif
192 #ifdef CONFIG_I2C_MVTWSI_BASE2
193         case 2:
194                 return (struct mvtwsi_registers *)CONFIG_I2C_MVTWSI_BASE2;
195 #endif
196 #ifdef CONFIG_I2C_MVTWSI_BASE3
197         case 3:
198                 return (struct mvtwsi_registers *)CONFIG_I2C_MVTWSI_BASE3;
199 #endif
200 #ifdef CONFIG_I2C_MVTWSI_BASE4
201         case 4:
202                 return (struct mvtwsi_registers *)CONFIG_I2C_MVTWSI_BASE4;
203 #endif
204 #ifdef CONFIG_I2C_MVTWSI_BASE5
205         case 5:
206                 return (struct mvtwsi_registers *)CONFIG_I2C_MVTWSI_BASE5;
207 #endif
208         default:
209                 printf("Missing mvtwsi controller %d base\n", adap->hwadapnr);
210                 break;
211         }
212
213         return NULL;
214 }
215 #endif
216
217 /*
218  * enum mvtwsi_error_class - types of I2C errors
219  */
220 enum mvtwsi_error_class {
221         /* The controller returned a different status than expected */
222         MVTWSI_ERROR_WRONG_STATUS       = 0x01,
223         /* The controller timed out */
224         MVTWSI_ERROR_TIMEOUT            = 0x02,
225 };
226
227 /*
228  * mvtwsi_error() - Build I2C return code from error information
229  *
230  * For debugging purposes, this function packs some information of an occurred
231  * error into a return code. These error codes are returned from I2C API
232  * functions (i2c_{read,write}, dm_i2c_{read,write}, etc.).
233  *
234  * @ec:         The error class of the error (enum mvtwsi_error_class).
235  * @lc:         The last value of the control register.
236  * @ls:         The last value of the status register.
237  * @es:         The expected value of the status register.
238  * @return The generated error code.
239  */
240 inline uint mvtwsi_error(uint ec, uint lc, uint ls, uint es)
241 {
242         return ((ec << 24) & 0xFF000000)
243                | ((lc << 16) & 0x00FF0000)
244                | ((ls << 8) & 0x0000FF00)
245                | (es & 0xFF);
246 }
247
248 /*
249  * twsi_wait() - Wait for I2C bus interrupt flag and check status, or time out.
250  *
251  * @return Zero if status is as expected, or a non-zero code if either a time
252  *         out occurred, or the status was not the expected one.
253  */
254 static int twsi_wait(struct mvtwsi_registers *twsi, int expected_status,
255                      uint tick)
256 {
257         int control, status;
258         int timeout = 1000;
259
260         do {
261                 control = readl(&twsi->control);
262                 if (control & MVTWSI_CONTROL_IFLG) {
263                         status = readl(&twsi->status);
264                         if (status == expected_status)
265                                 return 0;
266                         else
267                                 return mvtwsi_error(
268                                         MVTWSI_ERROR_WRONG_STATUS,
269                                         control, status, expected_status);
270                 }
271                 ndelay(tick); /* One clock cycle */
272         } while (timeout--);
273         status = readl(&twsi->status);
274         return mvtwsi_error(MVTWSI_ERROR_TIMEOUT, control, status,
275                             expected_status);
276 }
277
278 /*
279  * twsi_start() - Assert a START condition on the bus.
280  *
281  * This function is used in both single I2C transactions and inside
282  * back-to-back transactions (repeated starts).
283  *
284  * @twsi:               The MVTWSI register structure to use.
285  * @expected_status:    The I2C bus status expected to be asserted after the
286  *                      operation completion.
287  * @tick:               The duration of a clock cycle at the current I2C speed.
288  * @return Zero if status is as expected, or a non-zero code if either a time
289  *         out occurred or the status was not the expected one.
290  */
291 static int twsi_start(struct mvtwsi_registers *twsi, int expected_status,
292                       uint tick)
293 {
294         /* Assert START */
295         writel(MVTWSI_CONTROL_TWSIEN | MVTWSI_CONTROL_START |
296                MVTWSI_CONTROL_CLEAR_IFLG, &twsi->control);
297         /* Wait for controller to process START */
298         return twsi_wait(twsi, expected_status, tick);
299 }
300
301 /*
302  * twsi_send() - Send a byte on the I2C bus.
303  *
304  * The byte may be part of an address byte or data.
305  *
306  * @twsi:               The MVTWSI register structure to use.
307  * @byte:               The byte to send.
308  * @expected_status:    The I2C bus status expected to be asserted after the
309  *                      operation completion.
310  * @tick:               The duration of a clock cycle at the current I2C speed.
311  * @return Zero if status is as expected, or a non-zero code if either a time
312  *         out occurred or the status was not the expected one.
313  */
314 static int twsi_send(struct mvtwsi_registers *twsi, u8 byte,
315                      int expected_status, uint tick)
316 {
317         /* Write byte to data register for sending */
318         writel(byte, &twsi->data);
319         /* Clear any pending interrupt -- that will cause sending */
320         writel(MVTWSI_CONTROL_TWSIEN | MVTWSI_CONTROL_CLEAR_IFLG,
321                &twsi->control);
322         /* Wait for controller to receive byte, and check ACK */
323         return twsi_wait(twsi, expected_status, tick);
324 }
325
326 /*
327  * twsi_recv() - Receive a byte on the I2C bus.
328  *
329  * The static variable mvtwsi_control_flags controls whether we ack or nak.
330  *
331  * @twsi:               The MVTWSI register structure to use.
332  * @byte:               The byte to send.
333  * @ack_flag:           Flag that determines whether the received byte should
334  *                      be acknowledged by the controller or not (sent ACK/NAK).
335  * @tick:               The duration of a clock cycle at the current I2C speed.
336  * @return Zero if status is as expected, or a non-zero code if either a time
337  *         out occurred or the status was not the expected one.
338  */
339 static int twsi_recv(struct mvtwsi_registers *twsi, u8 *byte, int ack_flag,
340                      uint tick)
341 {
342         int expected_status, status, control;
343
344         /* Compute expected status based on passed ACK flag */
345         expected_status = ack_flag ? MVTWSI_STATUS_DATA_R_ACK :
346                           MVTWSI_STATUS_DATA_R_NAK;
347         /* Acknowledge *previous state*, and launch receive */
348         control = MVTWSI_CONTROL_TWSIEN;
349         control |= ack_flag == MVTWSI_READ_ACK ? MVTWSI_CONTROL_ACK : 0;
350         writel(control | MVTWSI_CONTROL_CLEAR_IFLG, &twsi->control);
351         /* Wait for controller to receive byte, and assert ACK or NAK */
352         status = twsi_wait(twsi, expected_status, tick);
353         /* If we did receive the expected byte, store it */
354         if (status == 0)
355                 *byte = readl(&twsi->data);
356         return status;
357 }
358
359 /*
360  * twsi_stop() - Assert a STOP condition on the bus.
361  *
362  * This function is also used to force the bus back to idle state (SDA =
363  * SCL = 1).
364  *
365  * @twsi:       The MVTWSI register structure to use.
366  * @tick:       The duration of a clock cycle at the current I2C speed.
367  * @return Zero if the operation succeeded, or a non-zero code if a time out
368  *         occurred.
369  */
370 static int twsi_stop(struct mvtwsi_registers *twsi, uint tick)
371 {
372         int control, stop_status;
373         int status = 0;
374         int timeout = 1000;
375
376         /* Assert STOP */
377         control = MVTWSI_CONTROL_TWSIEN | MVTWSI_CONTROL_STOP;
378         writel(control | MVTWSI_CONTROL_CLEAR_IFLG, &twsi->control);
379         /* Wait for IDLE; IFLG won't rise, so we can't use twsi_wait() */
380         do {
381                 stop_status = readl(&twsi->status);
382                 if (stop_status == MVTWSI_STATUS_IDLE)
383                         break;
384                 ndelay(tick); /* One clock cycle */
385         } while (timeout--);
386         control = readl(&twsi->control);
387         if (stop_status != MVTWSI_STATUS_IDLE)
388                 status = mvtwsi_error(MVTWSI_ERROR_TIMEOUT,
389                                       control, status, MVTWSI_STATUS_IDLE);
390         return status;
391 }
392
393 /*
394  * twsi_calc_freq() - Compute I2C frequency depending on m and n parameters.
395  *
396  * @n:          Parameter 'n' for the frequency calculation algorithm.
397  * @m:          Parameter 'm' for the frequency calculation algorithm.
398  * @return The I2C frequency corresponding to the passed m and n parameters.
399  */
400 static uint twsi_calc_freq(const int n, const int m)
401 {
402 #ifdef CONFIG_SUNXI
403         return CONFIG_SYS_TCLK / (10 * (m + 1) * (1 << n));
404 #else
405         return CONFIG_SYS_TCLK / (10 * (m + 1) * (2 << n));
406 #endif
407 }
408
409 /*
410  * twsi_reset() - Reset the I2C controller.
411  *
412  * Resetting the controller also resets the baud rate and slave address, hence
413  * they must be re-established after the reset.
414  *
415  * @twsi:       The MVTWSI register structure to use.
416  */
417 static void twsi_reset(struct mvtwsi_registers *twsi)
418 {
419         /* Reset controller */
420         writel(0, &twsi->soft_reset);
421         /* Wait 2 ms -- this is what the Marvell LSP does */
422         udelay(20000);
423 }
424
425 /*
426  * __twsi_i2c_set_bus_speed() - Set the speed of the I2C controller.
427  *
428  * This function sets baud rate to the highest possible value that does not
429  * exceed the requested rate.
430  *
431  * @twsi:               The MVTWSI register structure to use.
432  * @requested_speed:    The desired frequency the controller should run at
433  *                      in Hz.
434  * @return The actual frequency the controller was configured to.
435  */
436 static uint __twsi_i2c_set_bus_speed(struct mvtwsi_registers *twsi,
437                                      uint requested_speed)
438 {
439         uint tmp_speed, highest_speed, n, m;
440         uint baud = 0x44; /* Baud rate after controller reset */
441
442         highest_speed = 0;
443         /* Successively try m, n combinations, and use the combination
444          * resulting in the largest speed that's not above the requested
445          * speed */
446         for (n = 0; n < 8; n++) {
447                 for (m = 0; m < 16; m++) {
448                         tmp_speed = twsi_calc_freq(n, m);
449                         if ((tmp_speed <= requested_speed) &&
450                             (tmp_speed > highest_speed)) {
451                                 highest_speed = tmp_speed;
452                                 baud = (m << 3) | n;
453                         }
454                 }
455         }
456         writel(baud, &twsi->baudrate);
457
458         /* Wait for controller for one tick */
459 #ifdef CONFIG_DM_I2C
460         ndelay(calc_tick(highest_speed));
461 #else
462         ndelay(10000);
463 #endif
464         return highest_speed;
465 }
466
467 /*
468  * __twsi_i2c_init() - Initialize the I2C controller.
469  *
470  * @twsi:               The MVTWSI register structure to use.
471  * @speed:              The initial frequency the controller should run at
472  *                      in Hz.
473  * @slaveadd:           The I2C address to be set for the I2C master.
474  * @actual_speed:       A output parameter that receives the actual frequency
475  *                      in Hz the controller was set to by the function.
476  * @return Zero if the operation succeeded, or a non-zero code if a time out
477  *         occurred.
478  */
479 static void __twsi_i2c_init(struct mvtwsi_registers *twsi, int speed,
480                             int slaveadd, uint *actual_speed)
481 {
482         /* Reset controller */
483         twsi_reset(twsi);
484         /* Set speed */
485         *actual_speed = __twsi_i2c_set_bus_speed(twsi, speed);
486         /* Set slave address; even though we don't use it */
487         writel(slaveadd, &twsi->slave_address);
488         writel(0, &twsi->xtnd_slave_addr);
489         /* Assert STOP, but don't care for the result */
490 #ifdef CONFIG_DM_I2C
491         (void) twsi_stop(twsi, calc_tick(*actual_speed));
492 #else
493         (void) twsi_stop(twsi, 10000);
494 #endif
495 }
496
497 /*
498  * i2c_begin() - Start a I2C transaction.
499  *
500  * Begin a I2C transaction with a given expected start status and chip address.
501  * A START is asserted, and the address byte is sent to the I2C controller. The
502  * expected address status will be derived from the direction bit (bit 0) of
503  * the address byte.
504  *
505  * @twsi:                       The MVTWSI register structure to use.
506  * @expected_start_status:      The I2C status the controller is expected to
507  *                              assert after the address byte was sent.
508  * @addr:                       The address byte to be sent.
509  * @tick:                       The duration of a clock cycle at the current
510  *                              I2C speed.
511  * @return Zero if the operation succeeded, or a non-zero code if a time out or
512  *         unexpected I2C status occurred.
513  */
514 static int i2c_begin(struct mvtwsi_registers *twsi, int expected_start_status,
515                      u8 addr, uint tick)
516 {
517         int status, expected_addr_status;
518
519         /* Compute the expected address status from the direction bit in
520          * the address byte */
521         if (addr & 1) /* Reading */
522                 expected_addr_status = MVTWSI_STATUS_ADDR_R_ACK;
523         else /* Writing */
524                 expected_addr_status = MVTWSI_STATUS_ADDR_W_ACK;
525         /* Assert START */
526         status = twsi_start(twsi, expected_start_status, tick);
527         /* Send out the address if the start went well */
528         if (status == 0)
529                 status = twsi_send(twsi, addr, expected_addr_status, tick);
530         /* Return 0, or the status of the first failure */
531         return status;
532 }
533
534 /*
535  * __twsi_i2c_probe_chip() - Probe the given I2C chip address.
536  *
537  * This function begins a I2C read transaction, does a dummy read and NAKs; if
538  * the procedure succeeds, the chip is considered to be present.
539  *
540  * @twsi:       The MVTWSI register structure to use.
541  * @chip:       The chip address to probe.
542  * @tick:       The duration of a clock cycle at the current I2C speed.
543  * @return Zero if the operation succeeded, or a non-zero code if a time out or
544  *         unexpected I2C status occurred.
545  */
546 static int __twsi_i2c_probe_chip(struct mvtwsi_registers *twsi, uchar chip,
547                                  uint tick)
548 {
549         u8 dummy_byte;
550         int status;
551
552         /* Begin i2c read */
553         status = i2c_begin(twsi, MVTWSI_STATUS_START, (chip << 1) | 1, tick);
554         /* Dummy read was accepted: receive byte, but NAK it. */
555         if (status == 0)
556                 status = twsi_recv(twsi, &dummy_byte, MVTWSI_READ_NAK, tick);
557         /* Stop transaction */
558         twsi_stop(twsi, tick);
559         /* Return 0, or the status of the first failure */
560         return status;
561 }
562
563 /*
564  * __twsi_i2c_read() - Read data from a I2C chip.
565  *
566  * This function begins a I2C write transaction, and transmits the address
567  * bytes; then begins a I2C read transaction, and receives the data bytes.
568  *
569  * NOTE: Some devices want a stop right before the second start, while some
570  * will choke if it is there. Since deciding this is not yet supported in
571  * higher level APIs, we need to make a decision here, and for the moment that
572  * will be a repeated start without a preceding stop.
573  *
574  * @twsi:       The MVTWSI register structure to use.
575  * @chip:       The chip address to read from.
576  * @addr:       The address bytes to send.
577  * @alen:       The length of the address bytes in bytes.
578  * @data:       The buffer to receive the data read from the chip (has to have
579  *              a size of at least 'length' bytes).
580  * @length:     The amount of data to be read from the chip in bytes.
581  * @tick:       The duration of a clock cycle at the current I2C speed.
582  * @return Zero if the operation succeeded, or a non-zero code if a time out or
583  *         unexpected I2C status occurred.
584  */
585 static int __twsi_i2c_read(struct mvtwsi_registers *twsi, uchar chip,
586                            u8 *addr, int alen, uchar *data, int length,
587                            uint tick)
588 {
589         int status = 0;
590         int stop_status;
591         int expected_start = MVTWSI_STATUS_START;
592
593         if (alen > 0) {
594                 /* Begin i2c write to send the address bytes */
595                 status = i2c_begin(twsi, expected_start, (chip << 1), tick);
596                 /* Send address bytes */
597                 while ((status == 0) && alen--)
598                         status = twsi_send(twsi, addr[alen],
599                                            MVTWSI_STATUS_DATA_W_ACK, tick);
600                 /* Send repeated STARTs after the initial START */
601                 expected_start = MVTWSI_STATUS_REPEATED_START;
602         }
603         /* Begin i2c read to receive data bytes */
604         if (status == 0)
605                 status = i2c_begin(twsi, expected_start, (chip << 1) | 1, tick);
606         /* Receive actual data bytes; set NAK if we if we have nothing more to
607          * read */
608         while ((status == 0) && length--)
609                 status = twsi_recv(twsi, data++,
610                                    length > 0 ?
611                                    MVTWSI_READ_ACK : MVTWSI_READ_NAK, tick);
612         /* Stop transaction */
613         stop_status = twsi_stop(twsi, tick);
614         /* Return 0, or the status of the first failure */
615         return status != 0 ? status : stop_status;
616 }
617
618 /*
619  * __twsi_i2c_write() - Send data to a I2C chip.
620  *
621  * This function begins a I2C write transaction, and transmits the address
622  * bytes; then begins a new I2C write transaction, and sends the data bytes.
623  *
624  * @twsi:       The MVTWSI register structure to use.
625  * @chip:       The chip address to read from.
626  * @addr:       The address bytes to send.
627  * @alen:       The length of the address bytes in bytes.
628  * @data:       The buffer containing the data to be sent to the chip.
629  * @length:     The length of data to be sent to the chip in bytes.
630  * @tick:       The duration of a clock cycle at the current I2C speed.
631  * @return Zero if the operation succeeded, or a non-zero code if a time out or
632  *         unexpected I2C status occurred.
633  */
634 static int __twsi_i2c_write(struct mvtwsi_registers *twsi, uchar chip,
635                             u8 *addr, int alen, uchar *data, int length,
636                             uint tick)
637 {
638         int status, stop_status;
639
640         /* Begin i2c write to send first the address bytes, then the
641          * data bytes */
642         status = i2c_begin(twsi, MVTWSI_STATUS_START, (chip << 1), tick);
643         /* Send address bytes */
644         while ((status == 0) && (alen-- > 0))
645                 status = twsi_send(twsi, addr[alen], MVTWSI_STATUS_DATA_W_ACK,
646                                    tick);
647         /* Send data bytes */
648         while ((status == 0) && (length-- > 0))
649                 status = twsi_send(twsi, *(data++), MVTWSI_STATUS_DATA_W_ACK,
650                                    tick);
651         /* Stop transaction */
652         stop_status = twsi_stop(twsi, tick);
653         /* Return 0, or the status of the first failure */
654         return status != 0 ? status : stop_status;
655 }
656
657 #ifndef CONFIG_DM_I2C
658 static void twsi_i2c_init(struct i2c_adapter *adap, int speed,
659                           int slaveadd)
660 {
661         struct mvtwsi_registers *twsi = twsi_get_base(adap);
662         __twsi_i2c_init(twsi, speed, slaveadd, NULL);
663 }
664
665 static uint twsi_i2c_set_bus_speed(struct i2c_adapter *adap,
666                                    uint requested_speed)
667 {
668         struct mvtwsi_registers *twsi = twsi_get_base(adap);
669         __twsi_i2c_set_bus_speed(twsi, requested_speed);
670         return 0;
671 }
672
673 static int twsi_i2c_probe(struct i2c_adapter *adap, uchar chip)
674 {
675         struct mvtwsi_registers *twsi = twsi_get_base(adap);
676         return __twsi_i2c_probe_chip(twsi, chip, 10000);
677 }
678
679 static int twsi_i2c_read(struct i2c_adapter *adap, uchar chip, uint addr,
680                          int alen, uchar *data, int length)
681 {
682         struct mvtwsi_registers *twsi = twsi_get_base(adap);
683         u8 addr_bytes[4];
684
685         addr_bytes[0] = (addr >> 0) & 0xFF;
686         addr_bytes[1] = (addr >> 8) & 0xFF;
687         addr_bytes[2] = (addr >> 16) & 0xFF;
688         addr_bytes[3] = (addr >> 24) & 0xFF;
689
690         return __twsi_i2c_read(twsi, chip, addr_bytes, alen, data, length,
691                                10000);
692 }
693
694 static int twsi_i2c_write(struct i2c_adapter *adap, uchar chip, uint addr,
695                           int alen, uchar *data, int length)
696 {
697         struct mvtwsi_registers *twsi = twsi_get_base(adap);
698         u8 addr_bytes[4];
699
700         addr_bytes[0] = (addr >> 0) & 0xFF;
701         addr_bytes[1] = (addr >> 8) & 0xFF;
702         addr_bytes[2] = (addr >> 16) & 0xFF;
703         addr_bytes[3] = (addr >> 24) & 0xFF;
704
705         return __twsi_i2c_write(twsi, chip, addr_bytes, alen, data, length,
706                                 10000);
707 }
708
709 #ifdef CONFIG_I2C_MVTWSI_BASE0
710 U_BOOT_I2C_ADAP_COMPLETE(twsi0, twsi_i2c_init, twsi_i2c_probe,
711                          twsi_i2c_read, twsi_i2c_write,
712                          twsi_i2c_set_bus_speed,
713                          CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE, 0)
714 #endif
715 #ifdef CONFIG_I2C_MVTWSI_BASE1
716 U_BOOT_I2C_ADAP_COMPLETE(twsi1, twsi_i2c_init, twsi_i2c_probe,
717                          twsi_i2c_read, twsi_i2c_write,
718                          twsi_i2c_set_bus_speed,
719                          CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE, 1)
720
721 #endif
722 #ifdef CONFIG_I2C_MVTWSI_BASE2
723 U_BOOT_I2C_ADAP_COMPLETE(twsi2, twsi_i2c_init, twsi_i2c_probe,
724                          twsi_i2c_read, twsi_i2c_write,
725                          twsi_i2c_set_bus_speed,
726                          CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE, 2)
727
728 #endif
729 #ifdef CONFIG_I2C_MVTWSI_BASE3
730 U_BOOT_I2C_ADAP_COMPLETE(twsi3, twsi_i2c_init, twsi_i2c_probe,
731                          twsi_i2c_read, twsi_i2c_write,
732                          twsi_i2c_set_bus_speed,
733                          CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE, 3)
734
735 #endif
736 #ifdef CONFIG_I2C_MVTWSI_BASE4
737 U_BOOT_I2C_ADAP_COMPLETE(twsi4, twsi_i2c_init, twsi_i2c_probe,
738                          twsi_i2c_read, twsi_i2c_write,
739                          twsi_i2c_set_bus_speed,
740                          CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE, 4)
741
742 #endif
743 #ifdef CONFIG_I2C_MVTWSI_BASE5
744 U_BOOT_I2C_ADAP_COMPLETE(twsi5, twsi_i2c_init, twsi_i2c_probe,
745                          twsi_i2c_read, twsi_i2c_write,
746                          twsi_i2c_set_bus_speed,
747                          CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE, 5)
748
749 #endif
750 #else /* CONFIG_DM_I2C */
751
752 static int mvtwsi_i2c_probe_chip(struct udevice *bus, u32 chip_addr,
753                                  u32 chip_flags)
754 {
755         struct mvtwsi_i2c_dev *dev = dev_get_priv(bus);
756         return __twsi_i2c_probe_chip(dev->base, chip_addr, dev->tick);
757 }
758
759 static int mvtwsi_i2c_set_bus_speed(struct udevice *bus, uint speed)
760 {
761         struct mvtwsi_i2c_dev *dev = dev_get_priv(bus);
762
763         dev->speed = __twsi_i2c_set_bus_speed(dev->base, speed);
764         dev->tick = calc_tick(dev->speed);
765
766         return 0;
767 }
768
769 static int mvtwsi_i2c_ofdata_to_platdata(struct udevice *bus)
770 {
771         struct mvtwsi_i2c_dev *dev = dev_get_priv(bus);
772
773         dev->base = dev_get_addr_ptr(bus);
774
775         if (!dev->base)
776                 return -ENOMEM;
777
778         dev->index = fdtdec_get_int(gd->fdt_blob, bus->of_offset,
779                                     "cell-index", -1);
780         dev->slaveadd = fdtdec_get_int(gd->fdt_blob, bus->of_offset,
781                                        "u-boot,i2c-slave-addr", 0x0);
782         dev->speed = fdtdec_get_int(gd->fdt_blob, bus->of_offset,
783                                     "clock-frequency", 100000);
784         return 0;
785 }
786
787 static int mvtwsi_i2c_probe(struct udevice *bus)
788 {
789         struct mvtwsi_i2c_dev *dev = dev_get_priv(bus);
790         uint actual_speed;
791
792         __twsi_i2c_init(dev->base, dev->speed, dev->slaveadd, &actual_speed);
793         dev->speed = actual_speed;
794         dev->tick = calc_tick(dev->speed);
795         return 0;
796 }
797
798 static int mvtwsi_i2c_xfer(struct udevice *bus, struct i2c_msg *msg, int nmsgs)
799 {
800         struct mvtwsi_i2c_dev *dev = dev_get_priv(bus);
801         struct i2c_msg *dmsg, *omsg, dummy;
802
803         memset(&dummy, 0, sizeof(struct i2c_msg));
804
805         /* We expect either two messages (one with an offset and one with the
806          * actual data) or one message (just data or offset/data combined) */
807         if (nmsgs > 2 || nmsgs == 0) {
808                 debug("%s: Only one or two messages are supported.", __func__);
809                 return -1;
810         }
811
812         omsg = nmsgs == 1 ? &dummy : msg;
813         dmsg = nmsgs == 1 ? msg : msg + 1;
814
815         if (dmsg->flags & I2C_M_RD)
816                 return __twsi_i2c_read(dev->base, dmsg->addr, omsg->buf,
817                                        omsg->len, dmsg->buf, dmsg->len,
818                                        dev->tick);
819         else
820                 return __twsi_i2c_write(dev->base, dmsg->addr, omsg->buf,
821                                         omsg->len, dmsg->buf, dmsg->len,
822                                         dev->tick);
823 }
824
825 static const struct dm_i2c_ops mvtwsi_i2c_ops = {
826         .xfer           = mvtwsi_i2c_xfer,
827         .probe_chip     = mvtwsi_i2c_probe_chip,
828         .set_bus_speed  = mvtwsi_i2c_set_bus_speed,
829 };
830
831 static const struct udevice_id mvtwsi_i2c_ids[] = {
832         { .compatible = "marvell,mv64xxx-i2c", },
833         { /* sentinel */ }
834 };
835
836 U_BOOT_DRIVER(i2c_mvtwsi) = {
837         .name = "i2c_mvtwsi",
838         .id = UCLASS_I2C,
839         .of_match = mvtwsi_i2c_ids,
840         .probe = mvtwsi_i2c_probe,
841         .ofdata_to_platdata = mvtwsi_i2c_ofdata_to_platdata,
842         .priv_auto_alloc_size = sizeof(struct mvtwsi_i2c_dev),
843         .ops = &mvtwsi_i2c_ops,
844 };
845 #endif /* CONFIG_DM_I2C */