i2c-designware: Fix build error if CONFIG_I2C_DESIGNWARE_PLATFORM=y && CONFIG_I2C_DES...
[pandora-kernel.git] / drivers / i2c / busses / i2c-designware-core.c
1 /*
2  * Synopsys DesignWare I2C adapter driver (master only).
3  *
4  * Based on the TI DAVINCI I2C adapter driver.
5  *
6  * Copyright (C) 2006 Texas Instruments.
7  * Copyright (C) 2007 MontaVista Software Inc.
8  * Copyright (C) 2009 Provigent Ltd.
9  *
10  * ----------------------------------------------------------------------------
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation; either version 2 of the License, or
15  * (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25  * ----------------------------------------------------------------------------
26  *
27  */
28 #include <linux/export.h>
29 #include <linux/clk.h>
30 #include <linux/errno.h>
31 #include <linux/err.h>
32 #include <linux/i2c.h>
33 #include <linux/interrupt.h>
34 #include <linux/io.h>
35 #include <linux/pm_runtime.h>
36 #include <linux/delay.h>
37 #include "i2c-designware-core.h"
38
39 /*
40  * Registers offset
41  */
42 #define DW_IC_CON               0x0
43 #define DW_IC_TAR               0x4
44 #define DW_IC_DATA_CMD          0x10
45 #define DW_IC_SS_SCL_HCNT       0x14
46 #define DW_IC_SS_SCL_LCNT       0x18
47 #define DW_IC_FS_SCL_HCNT       0x1c
48 #define DW_IC_FS_SCL_LCNT       0x20
49 #define DW_IC_INTR_STAT         0x2c
50 #define DW_IC_INTR_MASK         0x30
51 #define DW_IC_RAW_INTR_STAT     0x34
52 #define DW_IC_RX_TL             0x38
53 #define DW_IC_TX_TL             0x3c
54 #define DW_IC_CLR_INTR          0x40
55 #define DW_IC_CLR_RX_UNDER      0x44
56 #define DW_IC_CLR_RX_OVER       0x48
57 #define DW_IC_CLR_TX_OVER       0x4c
58 #define DW_IC_CLR_RD_REQ        0x50
59 #define DW_IC_CLR_TX_ABRT       0x54
60 #define DW_IC_CLR_RX_DONE       0x58
61 #define DW_IC_CLR_ACTIVITY      0x5c
62 #define DW_IC_CLR_STOP_DET      0x60
63 #define DW_IC_CLR_START_DET     0x64
64 #define DW_IC_CLR_GEN_CALL      0x68
65 #define DW_IC_ENABLE            0x6c
66 #define DW_IC_STATUS            0x70
67 #define DW_IC_TXFLR             0x74
68 #define DW_IC_RXFLR             0x78
69 #define DW_IC_TX_ABRT_SOURCE    0x80
70 #define DW_IC_COMP_PARAM_1      0xf4
71 #define DW_IC_COMP_TYPE         0xfc
72 #define DW_IC_COMP_TYPE_VALUE   0x44570140
73
74 #define DW_IC_INTR_RX_UNDER     0x001
75 #define DW_IC_INTR_RX_OVER      0x002
76 #define DW_IC_INTR_RX_FULL      0x004
77 #define DW_IC_INTR_TX_OVER      0x008
78 #define DW_IC_INTR_TX_EMPTY     0x010
79 #define DW_IC_INTR_RD_REQ       0x020
80 #define DW_IC_INTR_TX_ABRT      0x040
81 #define DW_IC_INTR_RX_DONE      0x080
82 #define DW_IC_INTR_ACTIVITY     0x100
83 #define DW_IC_INTR_STOP_DET     0x200
84 #define DW_IC_INTR_START_DET    0x400
85 #define DW_IC_INTR_GEN_CALL     0x800
86
87 #define DW_IC_INTR_DEFAULT_MASK         (DW_IC_INTR_RX_FULL | \
88                                          DW_IC_INTR_TX_EMPTY | \
89                                          DW_IC_INTR_TX_ABRT | \
90                                          DW_IC_INTR_STOP_DET)
91
92 #define DW_IC_STATUS_ACTIVITY   0x1
93
94 #define DW_IC_ERR_TX_ABRT       0x1
95
96 /*
97  * status codes
98  */
99 #define STATUS_IDLE                     0x0
100 #define STATUS_WRITE_IN_PROGRESS        0x1
101 #define STATUS_READ_IN_PROGRESS         0x2
102
103 #define TIMEOUT                 20 /* ms */
104
105 /*
106  * hardware abort codes from the DW_IC_TX_ABRT_SOURCE register
107  *
108  * only expected abort codes are listed here
109  * refer to the datasheet for the full list
110  */
111 #define ABRT_7B_ADDR_NOACK      0
112 #define ABRT_10ADDR1_NOACK      1
113 #define ABRT_10ADDR2_NOACK      2
114 #define ABRT_TXDATA_NOACK       3
115 #define ABRT_GCALL_NOACK        4
116 #define ABRT_GCALL_READ         5
117 #define ABRT_SBYTE_ACKDET       7
118 #define ABRT_SBYTE_NORSTRT      9
119 #define ABRT_10B_RD_NORSTRT     10
120 #define ABRT_MASTER_DIS         11
121 #define ARB_LOST                12
122
123 #define DW_IC_TX_ABRT_7B_ADDR_NOACK     (1UL << ABRT_7B_ADDR_NOACK)
124 #define DW_IC_TX_ABRT_10ADDR1_NOACK     (1UL << ABRT_10ADDR1_NOACK)
125 #define DW_IC_TX_ABRT_10ADDR2_NOACK     (1UL << ABRT_10ADDR2_NOACK)
126 #define DW_IC_TX_ABRT_TXDATA_NOACK      (1UL << ABRT_TXDATA_NOACK)
127 #define DW_IC_TX_ABRT_GCALL_NOACK       (1UL << ABRT_GCALL_NOACK)
128 #define DW_IC_TX_ABRT_GCALL_READ        (1UL << ABRT_GCALL_READ)
129 #define DW_IC_TX_ABRT_SBYTE_ACKDET      (1UL << ABRT_SBYTE_ACKDET)
130 #define DW_IC_TX_ABRT_SBYTE_NORSTRT     (1UL << ABRT_SBYTE_NORSTRT)
131 #define DW_IC_TX_ABRT_10B_RD_NORSTRT    (1UL << ABRT_10B_RD_NORSTRT)
132 #define DW_IC_TX_ABRT_MASTER_DIS        (1UL << ABRT_MASTER_DIS)
133 #define DW_IC_TX_ARB_LOST               (1UL << ARB_LOST)
134
135 #define DW_IC_TX_ABRT_NOACK             (DW_IC_TX_ABRT_7B_ADDR_NOACK | \
136                                          DW_IC_TX_ABRT_10ADDR1_NOACK | \
137                                          DW_IC_TX_ABRT_10ADDR2_NOACK | \
138                                          DW_IC_TX_ABRT_TXDATA_NOACK | \
139                                          DW_IC_TX_ABRT_GCALL_NOACK)
140
141 static char *abort_sources[] = {
142         [ABRT_7B_ADDR_NOACK] =
143                 "slave address not acknowledged (7bit mode)",
144         [ABRT_10ADDR1_NOACK] =
145                 "first address byte not acknowledged (10bit mode)",
146         [ABRT_10ADDR2_NOACK] =
147                 "second address byte not acknowledged (10bit mode)",
148         [ABRT_TXDATA_NOACK] =
149                 "data not acknowledged",
150         [ABRT_GCALL_NOACK] =
151                 "no acknowledgement for a general call",
152         [ABRT_GCALL_READ] =
153                 "read after general call",
154         [ABRT_SBYTE_ACKDET] =
155                 "start byte acknowledged",
156         [ABRT_SBYTE_NORSTRT] =
157                 "trying to send start byte when restart is disabled",
158         [ABRT_10B_RD_NORSTRT] =
159                 "trying to read when restart is disabled (10bit mode)",
160         [ABRT_MASTER_DIS] =
161                 "trying to use disabled adapter",
162         [ARB_LOST] =
163                 "lost arbitration",
164 };
165
166 u32 dw_readl(struct dw_i2c_dev *dev, int offset)
167 {
168         u32 value = readl(dev->base + offset);
169
170         if (dev->swab)
171                 return swab32(value);
172         else
173                 return value;
174 }
175
176 void dw_writel(struct dw_i2c_dev *dev, u32 b, int offset)
177 {
178         if (dev->swab)
179                 b = swab32(b);
180
181         writel(b, dev->base + offset);
182 }
183
184 static u32
185 i2c_dw_scl_hcnt(u32 ic_clk, u32 tSYMBOL, u32 tf, int cond, int offset)
186 {
187         /*
188          * DesignWare I2C core doesn't seem to have solid strategy to meet
189          * the tHD;STA timing spec.  Configuring _HCNT based on tHIGH spec
190          * will result in violation of the tHD;STA spec.
191          */
192         if (cond)
193                 /*
194                  * Conditional expression:
195                  *
196                  *   IC_[FS]S_SCL_HCNT + (1+4+3) >= IC_CLK * tHIGH
197                  *
198                  * This is based on the DW manuals, and represents an ideal
199                  * configuration.  The resulting I2C bus speed will be
200                  * faster than any of the others.
201                  *
202                  * If your hardware is free from tHD;STA issue, try this one.
203                  */
204                 return (ic_clk * tSYMBOL + 5000) / 10000 - 8 + offset;
205         else
206                 /*
207                  * Conditional expression:
208                  *
209                  *   IC_[FS]S_SCL_HCNT + 3 >= IC_CLK * (tHD;STA + tf)
210                  *
211                  * This is just experimental rule; the tHD;STA period turned
212                  * out to be proportinal to (_HCNT + 3).  With this setting,
213                  * we could meet both tHIGH and tHD;STA timing specs.
214                  *
215                  * If unsure, you'd better to take this alternative.
216                  *
217                  * The reason why we need to take into account "tf" here,
218                  * is the same as described in i2c_dw_scl_lcnt().
219                  */
220                 return (ic_clk * (tSYMBOL + tf) + 5000) / 10000 - 3 + offset;
221 }
222
223 static u32 i2c_dw_scl_lcnt(u32 ic_clk, u32 tLOW, u32 tf, int offset)
224 {
225         /*
226          * Conditional expression:
227          *
228          *   IC_[FS]S_SCL_LCNT + 1 >= IC_CLK * (tLOW + tf)
229          *
230          * DW I2C core starts counting the SCL CNTs for the LOW period
231          * of the SCL clock (tLOW) as soon as it pulls the SCL line.
232          * In order to meet the tLOW timing spec, we need to take into
233          * account the fall time of SCL signal (tf).  Default tf value
234          * should be 0.3 us, for safety.
235          */
236         return ((ic_clk * (tLOW + tf) + 5000) / 10000) - 1 + offset;
237 }
238
239 /**
240  * i2c_dw_init() - initialize the designware i2c master hardware
241  * @dev: device private data
242  *
243  * This functions configures and enables the I2C master.
244  * This function is called during I2C init function, and in case of timeout at
245  * run time.
246  */
247 int i2c_dw_init(struct dw_i2c_dev *dev)
248 {
249         u32 input_clock_khz;
250         u32 hcnt, lcnt;
251         u32 reg;
252
253         input_clock_khz = dev->get_clk_rate_khz(dev);
254
255         /* Configure register endianess access */
256         reg = dw_readl(dev, DW_IC_COMP_TYPE);
257         if (reg == ___constant_swab32(DW_IC_COMP_TYPE_VALUE)) {
258                 dev->swab = 1;
259                 reg = DW_IC_COMP_TYPE_VALUE;
260         }
261
262         if (reg != DW_IC_COMP_TYPE_VALUE) {
263                 dev_err(dev->dev, "Unknown Synopsys component type: "
264                         "0x%08x\n", reg);
265                 return -ENODEV;
266         }
267
268         /* Disable the adapter */
269         dw_writel(dev, 0, DW_IC_ENABLE);
270
271         /* set standard and fast speed deviders for high/low periods */
272
273         /* Standard-mode */
274         hcnt = i2c_dw_scl_hcnt(input_clock_khz,
275                                 40,     /* tHD;STA = tHIGH = 4.0 us */
276                                 3,      /* tf = 0.3 us */
277                                 0,      /* 0: DW default, 1: Ideal */
278                                 0);     /* No offset */
279         lcnt = i2c_dw_scl_lcnt(input_clock_khz,
280                                 47,     /* tLOW = 4.7 us */
281                                 3,      /* tf = 0.3 us */
282                                 0);     /* No offset */
283         dw_writel(dev, hcnt, DW_IC_SS_SCL_HCNT);
284         dw_writel(dev, lcnt, DW_IC_SS_SCL_LCNT);
285         dev_dbg(dev->dev, "Standard-mode HCNT:LCNT = %d:%d\n", hcnt, lcnt);
286
287         /* Fast-mode */
288         hcnt = i2c_dw_scl_hcnt(input_clock_khz,
289                                 6,      /* tHD;STA = tHIGH = 0.6 us */
290                                 3,      /* tf = 0.3 us */
291                                 0,      /* 0: DW default, 1: Ideal */
292                                 0);     /* No offset */
293         lcnt = i2c_dw_scl_lcnt(input_clock_khz,
294                                 13,     /* tLOW = 1.3 us */
295                                 3,      /* tf = 0.3 us */
296                                 0);     /* No offset */
297         dw_writel(dev, hcnt, DW_IC_FS_SCL_HCNT);
298         dw_writel(dev, lcnt, DW_IC_FS_SCL_LCNT);
299         dev_dbg(dev->dev, "Fast-mode HCNT:LCNT = %d:%d\n", hcnt, lcnt);
300
301         /* Configure Tx/Rx FIFO threshold levels */
302         dw_writel(dev, dev->tx_fifo_depth - 1, DW_IC_TX_TL);
303         dw_writel(dev, 0, DW_IC_RX_TL);
304
305         /* configure the i2c master */
306         dw_writel(dev, dev->master_cfg , DW_IC_CON);
307         return 0;
308 }
309 EXPORT_SYMBOL_GPL(i2c_dw_init);
310
311 /*
312  * Waiting for bus not busy
313  */
314 static int i2c_dw_wait_bus_not_busy(struct dw_i2c_dev *dev)
315 {
316         int timeout = TIMEOUT;
317
318         while (dw_readl(dev, DW_IC_STATUS) & DW_IC_STATUS_ACTIVITY) {
319                 if (timeout <= 0) {
320                         dev_warn(dev->dev, "timeout waiting for bus ready\n");
321                         return -ETIMEDOUT;
322                 }
323                 timeout--;
324                 mdelay(1);
325         }
326
327         return 0;
328 }
329
330 static void i2c_dw_xfer_init(struct dw_i2c_dev *dev)
331 {
332         struct i2c_msg *msgs = dev->msgs;
333         u32 ic_con;
334
335         /* Disable the adapter */
336         dw_writel(dev, 0, DW_IC_ENABLE);
337
338         /* set the slave (target) address */
339         dw_writel(dev, msgs[dev->msg_write_idx].addr, DW_IC_TAR);
340
341         /* if the slave address is ten bit address, enable 10BITADDR */
342         ic_con = dw_readl(dev, DW_IC_CON);
343         if (msgs[dev->msg_write_idx].flags & I2C_M_TEN)
344                 ic_con |= DW_IC_CON_10BITADDR_MASTER;
345         else
346                 ic_con &= ~DW_IC_CON_10BITADDR_MASTER;
347         dw_writel(dev, ic_con, DW_IC_CON);
348
349         /* Enable the adapter */
350         dw_writel(dev, 1, DW_IC_ENABLE);
351
352         /* Enable interrupts */
353         dw_writel(dev, DW_IC_INTR_DEFAULT_MASK, DW_IC_INTR_MASK);
354 }
355
356 /*
357  * Initiate (and continue) low level master read/write transaction.
358  * This function is only called from i2c_dw_isr, and pumping i2c_msg
359  * messages into the tx buffer.  Even if the size of i2c_msg data is
360  * longer than the size of the tx buffer, it handles everything.
361  */
362 void
363 i2c_dw_xfer_msg(struct dw_i2c_dev *dev)
364 {
365         struct i2c_msg *msgs = dev->msgs;
366         u32 intr_mask;
367         int tx_limit, rx_limit;
368         u32 addr = msgs[dev->msg_write_idx].addr;
369         u32 buf_len = dev->tx_buf_len;
370         u8 *buf = dev->tx_buf;
371
372         intr_mask = DW_IC_INTR_DEFAULT_MASK;
373
374         for (; dev->msg_write_idx < dev->msgs_num; dev->msg_write_idx++) {
375                 /*
376                  * if target address has changed, we need to
377                  * reprogram the target address in the i2c
378                  * adapter when we are done with this transfer
379                  */
380                 if (msgs[dev->msg_write_idx].addr != addr) {
381                         dev_err(dev->dev,
382                                 "%s: invalid target address\n", __func__);
383                         dev->msg_err = -EINVAL;
384                         break;
385                 }
386
387                 if (msgs[dev->msg_write_idx].len == 0) {
388                         dev_err(dev->dev,
389                                 "%s: invalid message length\n", __func__);
390                         dev->msg_err = -EINVAL;
391                         break;
392                 }
393
394                 if (!(dev->status & STATUS_WRITE_IN_PROGRESS)) {
395                         /* new i2c_msg */
396                         buf = msgs[dev->msg_write_idx].buf;
397                         buf_len = msgs[dev->msg_write_idx].len;
398                 }
399
400                 tx_limit = dev->tx_fifo_depth - dw_readl(dev, DW_IC_TXFLR);
401                 rx_limit = dev->rx_fifo_depth - dw_readl(dev, DW_IC_RXFLR);
402
403                 while (buf_len > 0 && tx_limit > 0 && rx_limit > 0) {
404                         if (msgs[dev->msg_write_idx].flags & I2C_M_RD) {
405                                 dw_writel(dev, 0x100, DW_IC_DATA_CMD);
406                                 rx_limit--;
407                         } else
408                                 dw_writel(dev, *buf++, DW_IC_DATA_CMD);
409                         tx_limit--; buf_len--;
410                 }
411
412                 dev->tx_buf = buf;
413                 dev->tx_buf_len = buf_len;
414
415                 if (buf_len > 0) {
416                         /* more bytes to be written */
417                         dev->status |= STATUS_WRITE_IN_PROGRESS;
418                         break;
419                 } else
420                         dev->status &= ~STATUS_WRITE_IN_PROGRESS;
421         }
422
423         /*
424          * If i2c_msg index search is completed, we don't need TX_EMPTY
425          * interrupt any more.
426          */
427         if (dev->msg_write_idx == dev->msgs_num)
428                 intr_mask &= ~DW_IC_INTR_TX_EMPTY;
429
430         if (dev->msg_err)
431                 intr_mask = 0;
432
433         dw_writel(dev, intr_mask,  DW_IC_INTR_MASK);
434 }
435
436 static void
437 i2c_dw_read(struct dw_i2c_dev *dev)
438 {
439         struct i2c_msg *msgs = dev->msgs;
440         int rx_valid;
441
442         for (; dev->msg_read_idx < dev->msgs_num; dev->msg_read_idx++) {
443                 u32 len;
444                 u8 *buf;
445
446                 if (!(msgs[dev->msg_read_idx].flags & I2C_M_RD))
447                         continue;
448
449                 if (!(dev->status & STATUS_READ_IN_PROGRESS)) {
450                         len = msgs[dev->msg_read_idx].len;
451                         buf = msgs[dev->msg_read_idx].buf;
452                 } else {
453                         len = dev->rx_buf_len;
454                         buf = dev->rx_buf;
455                 }
456
457                 rx_valid = dw_readl(dev, DW_IC_RXFLR);
458
459                 for (; len > 0 && rx_valid > 0; len--, rx_valid--)
460                         *buf++ = dw_readl(dev, DW_IC_DATA_CMD);
461
462                 if (len > 0) {
463                         dev->status |= STATUS_READ_IN_PROGRESS;
464                         dev->rx_buf_len = len;
465                         dev->rx_buf = buf;
466                         return;
467                 } else
468                         dev->status &= ~STATUS_READ_IN_PROGRESS;
469         }
470 }
471
472 static int i2c_dw_handle_tx_abort(struct dw_i2c_dev *dev)
473 {
474         unsigned long abort_source = dev->abort_source;
475         int i;
476
477         if (abort_source & DW_IC_TX_ABRT_NOACK) {
478                 for_each_set_bit(i, &abort_source, ARRAY_SIZE(abort_sources))
479                         dev_dbg(dev->dev,
480                                 "%s: %s\n", __func__, abort_sources[i]);
481                 return -EREMOTEIO;
482         }
483
484         for_each_set_bit(i, &abort_source, ARRAY_SIZE(abort_sources))
485                 dev_err(dev->dev, "%s: %s\n", __func__, abort_sources[i]);
486
487         if (abort_source & DW_IC_TX_ARB_LOST)
488                 return -EAGAIN;
489         else if (abort_source & DW_IC_TX_ABRT_GCALL_READ)
490                 return -EINVAL; /* wrong msgs[] data */
491         else
492                 return -EIO;
493 }
494
495 /*
496  * Prepare controller for a transaction and call i2c_dw_xfer_msg
497  */
498 int
499 i2c_dw_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num)
500 {
501         struct dw_i2c_dev *dev = i2c_get_adapdata(adap);
502         int ret;
503
504         dev_dbg(dev->dev, "%s: msgs: %d\n", __func__, num);
505
506         mutex_lock(&dev->lock);
507         pm_runtime_get_sync(dev->dev);
508
509         INIT_COMPLETION(dev->cmd_complete);
510         dev->msgs = msgs;
511         dev->msgs_num = num;
512         dev->cmd_err = 0;
513         dev->msg_write_idx = 0;
514         dev->msg_read_idx = 0;
515         dev->msg_err = 0;
516         dev->status = STATUS_IDLE;
517         dev->abort_source = 0;
518
519         ret = i2c_dw_wait_bus_not_busy(dev);
520         if (ret < 0)
521                 goto done;
522
523         /* start the transfers */
524         i2c_dw_xfer_init(dev);
525
526         /* wait for tx to complete */
527         ret = wait_for_completion_interruptible_timeout(&dev->cmd_complete, HZ);
528         if (ret == 0) {
529                 dev_err(dev->dev, "controller timed out\n");
530                 i2c_dw_init(dev);
531                 ret = -ETIMEDOUT;
532                 goto done;
533         } else if (ret < 0)
534                 goto done;
535
536         if (dev->msg_err) {
537                 ret = dev->msg_err;
538                 goto done;
539         }
540
541         /* no error */
542         if (likely(!dev->cmd_err)) {
543                 /* Disable the adapter */
544                 dw_writel(dev, 0, DW_IC_ENABLE);
545                 ret = num;
546                 goto done;
547         }
548
549         /* We have an error */
550         if (dev->cmd_err == DW_IC_ERR_TX_ABRT) {
551                 ret = i2c_dw_handle_tx_abort(dev);
552                 goto done;
553         }
554         ret = -EIO;
555
556 done:
557         pm_runtime_put(dev->dev);
558         mutex_unlock(&dev->lock);
559
560         return ret;
561 }
562 EXPORT_SYMBOL_GPL(i2c_dw_xfer);
563
564 u32 i2c_dw_func(struct i2c_adapter *adap)
565 {
566         struct dw_i2c_dev *dev = i2c_get_adapdata(adap);
567         return dev->functionality;
568 }
569 EXPORT_SYMBOL_GPL(i2c_dw_func);
570
571 static u32 i2c_dw_read_clear_intrbits(struct dw_i2c_dev *dev)
572 {
573         u32 stat;
574
575         /*
576          * The IC_INTR_STAT register just indicates "enabled" interrupts.
577          * Ths unmasked raw version of interrupt status bits are available
578          * in the IC_RAW_INTR_STAT register.
579          *
580          * That is,
581          *   stat = dw_readl(IC_INTR_STAT);
582          * equals to,
583          *   stat = dw_readl(IC_RAW_INTR_STAT) & dw_readl(IC_INTR_MASK);
584          *
585          * The raw version might be useful for debugging purposes.
586          */
587         stat = dw_readl(dev, DW_IC_INTR_STAT);
588
589         /*
590          * Do not use the IC_CLR_INTR register to clear interrupts, or
591          * you'll miss some interrupts, triggered during the period from
592          * dw_readl(IC_INTR_STAT) to dw_readl(IC_CLR_INTR).
593          *
594          * Instead, use the separately-prepared IC_CLR_* registers.
595          */
596         if (stat & DW_IC_INTR_RX_UNDER)
597                 dw_readl(dev, DW_IC_CLR_RX_UNDER);
598         if (stat & DW_IC_INTR_RX_OVER)
599                 dw_readl(dev, DW_IC_CLR_RX_OVER);
600         if (stat & DW_IC_INTR_TX_OVER)
601                 dw_readl(dev, DW_IC_CLR_TX_OVER);
602         if (stat & DW_IC_INTR_RD_REQ)
603                 dw_readl(dev, DW_IC_CLR_RD_REQ);
604         if (stat & DW_IC_INTR_TX_ABRT) {
605                 /*
606                  * The IC_TX_ABRT_SOURCE register is cleared whenever
607                  * the IC_CLR_TX_ABRT is read.  Preserve it beforehand.
608                  */
609                 dev->abort_source = dw_readl(dev, DW_IC_TX_ABRT_SOURCE);
610                 dw_readl(dev, DW_IC_CLR_TX_ABRT);
611         }
612         if (stat & DW_IC_INTR_RX_DONE)
613                 dw_readl(dev, DW_IC_CLR_RX_DONE);
614         if (stat & DW_IC_INTR_ACTIVITY)
615                 dw_readl(dev, DW_IC_CLR_ACTIVITY);
616         if (stat & DW_IC_INTR_STOP_DET)
617                 dw_readl(dev, DW_IC_CLR_STOP_DET);
618         if (stat & DW_IC_INTR_START_DET)
619                 dw_readl(dev, DW_IC_CLR_START_DET);
620         if (stat & DW_IC_INTR_GEN_CALL)
621                 dw_readl(dev, DW_IC_CLR_GEN_CALL);
622
623         return stat;
624 }
625
626 /*
627  * Interrupt service routine. This gets called whenever an I2C interrupt
628  * occurs.
629  */
630 irqreturn_t i2c_dw_isr(int this_irq, void *dev_id)
631 {
632         struct dw_i2c_dev *dev = dev_id;
633         u32 stat, enabled;
634
635         enabled = dw_readl(dev, DW_IC_ENABLE);
636         stat = dw_readl(dev, DW_IC_RAW_INTR_STAT);
637         dev_dbg(dev->dev, "%s:  %s enabled= 0x%x stat=0x%x\n", __func__,
638                 dev->adapter.name, enabled, stat);
639         if (!enabled || !(stat & ~DW_IC_INTR_ACTIVITY))
640                 return IRQ_NONE;
641
642         stat = i2c_dw_read_clear_intrbits(dev);
643
644         if (stat & DW_IC_INTR_TX_ABRT) {
645                 dev->cmd_err |= DW_IC_ERR_TX_ABRT;
646                 dev->status = STATUS_IDLE;
647
648                 /*
649                  * Anytime TX_ABRT is set, the contents of the tx/rx
650                  * buffers are flushed.  Make sure to skip them.
651                  */
652                 dw_writel(dev, 0, DW_IC_INTR_MASK);
653                 goto tx_aborted;
654         }
655
656         if (stat & DW_IC_INTR_RX_FULL)
657                 i2c_dw_read(dev);
658
659         if (stat & DW_IC_INTR_TX_EMPTY)
660                 i2c_dw_xfer_msg(dev);
661
662         /*
663          * No need to modify or disable the interrupt mask here.
664          * i2c_dw_xfer_msg() will take care of it according to
665          * the current transmit status.
666          */
667
668 tx_aborted:
669         if ((stat & (DW_IC_INTR_TX_ABRT | DW_IC_INTR_STOP_DET)) || dev->msg_err)
670                 complete(&dev->cmd_complete);
671
672         return IRQ_HANDLED;
673 }
674 EXPORT_SYMBOL_GPL(i2c_dw_isr);
675
676 void i2c_dw_enable(struct dw_i2c_dev *dev)
677 {
678        /* Enable the adapter */
679         dw_writel(dev, 1, DW_IC_ENABLE);
680 }
681 EXPORT_SYMBOL_GPL(i2c_dw_enable);
682
683 u32 i2c_dw_is_enabled(struct dw_i2c_dev *dev)
684 {
685         return dw_readl(dev, DW_IC_ENABLE);
686 }
687 EXPORT_SYMBOL_GPL(i2c_dw_is_enabled);
688
689 void i2c_dw_disable(struct dw_i2c_dev *dev)
690 {
691         /* Disable controller */
692         dw_writel(dev, 0, DW_IC_ENABLE);
693
694         /* Disable all interupts */
695         dw_writel(dev, 0, DW_IC_INTR_MASK);
696         dw_readl(dev, DW_IC_CLR_INTR);
697 }
698 EXPORT_SYMBOL_GPL(i2c_dw_disable);
699
700 void i2c_dw_clear_int(struct dw_i2c_dev *dev)
701 {
702         dw_readl(dev, DW_IC_CLR_INTR);
703 }
704 EXPORT_SYMBOL_GPL(i2c_dw_clear_int);
705
706 void i2c_dw_disable_int(struct dw_i2c_dev *dev)
707 {
708         dw_writel(dev, 0, DW_IC_INTR_MASK);
709 }
710 EXPORT_SYMBOL_GPL(i2c_dw_disable_int);
711
712 u32 i2c_dw_read_comp_param(struct dw_i2c_dev *dev)
713 {
714         return dw_readl(dev, DW_IC_COMP_PARAM_1);
715 }
716 EXPORT_SYMBOL_GPL(i2c_dw_read_comp_param);