2 * Synopsys Designware I2C adapter driver (master only).
4 * Based on the TI DAVINCI I2C adapter driver.
6 * Copyright (C) 2006 Texas Instruments.
7 * Copyright (C) 2007 MontaVista Software Inc.
8 * Copyright (C) 2009 Provigent Ltd.
10 * ----------------------------------------------------------------------------
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.
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.
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 * ----------------------------------------------------------------------------
28 #include <linux/kernel.h>
29 #include <linux/module.h>
30 #include <linux/delay.h>
31 #include <linux/i2c.h>
32 #include <linux/clk.h>
33 #include <linux/errno.h>
34 #include <linux/sched.h>
35 #include <linux/err.h>
36 #include <linux/interrupt.h>
37 #include <linux/platform_device.h>
45 #define DW_IC_DATA_CMD 0x10
46 #define DW_IC_SS_SCL_HCNT 0x14
47 #define DW_IC_SS_SCL_LCNT 0x18
48 #define DW_IC_FS_SCL_HCNT 0x1c
49 #define DW_IC_FS_SCL_LCNT 0x20
50 #define DW_IC_INTR_STAT 0x2c
51 #define DW_IC_INTR_MASK 0x30
52 #define DW_IC_RAW_INTR_STAT 0x34
53 #define DW_IC_RX_TL 0x38
54 #define DW_IC_TX_TL 0x3c
55 #define DW_IC_CLR_INTR 0x40
56 #define DW_IC_CLR_RX_UNDER 0x44
57 #define DW_IC_CLR_RX_OVER 0x48
58 #define DW_IC_CLR_TX_OVER 0x4c
59 #define DW_IC_CLR_RD_REQ 0x50
60 #define DW_IC_CLR_TX_ABRT 0x54
61 #define DW_IC_CLR_RX_DONE 0x58
62 #define DW_IC_CLR_ACTIVITY 0x5c
63 #define DW_IC_CLR_STOP_DET 0x60
64 #define DW_IC_CLR_START_DET 0x64
65 #define DW_IC_CLR_GEN_CALL 0x68
66 #define DW_IC_ENABLE 0x6c
67 #define DW_IC_STATUS 0x70
68 #define DW_IC_TXFLR 0x74
69 #define DW_IC_RXFLR 0x78
70 #define DW_IC_COMP_PARAM_1 0xf4
71 #define DW_IC_TX_ABRT_SOURCE 0x80
73 #define DW_IC_CON_MASTER 0x1
74 #define DW_IC_CON_SPEED_STD 0x2
75 #define DW_IC_CON_SPEED_FAST 0x4
76 #define DW_IC_CON_10BITADDR_MASTER 0x10
77 #define DW_IC_CON_RESTART_EN 0x20
78 #define DW_IC_CON_SLAVE_DISABLE 0x40
80 #define DW_IC_INTR_RX_UNDER 0x001
81 #define DW_IC_INTR_RX_OVER 0x002
82 #define DW_IC_INTR_RX_FULL 0x004
83 #define DW_IC_INTR_TX_OVER 0x008
84 #define DW_IC_INTR_TX_EMPTY 0x010
85 #define DW_IC_INTR_RD_REQ 0x020
86 #define DW_IC_INTR_TX_ABRT 0x040
87 #define DW_IC_INTR_RX_DONE 0x080
88 #define DW_IC_INTR_ACTIVITY 0x100
89 #define DW_IC_INTR_STOP_DET 0x200
90 #define DW_IC_INTR_START_DET 0x400
91 #define DW_IC_INTR_GEN_CALL 0x800
93 #define DW_IC_STATUS_ACTIVITY 0x1
95 #define DW_IC_ERR_TX_ABRT 0x1
100 #define STATUS_IDLE 0x0
101 #define STATUS_WRITE_IN_PROGRESS 0x1
102 #define STATUS_READ_IN_PROGRESS 0x2
104 #define TIMEOUT 20 /* ms */
107 * hardware abort codes from the DW_IC_TX_ABRT_SOURCE register
109 * only expected abort codes are listed here
110 * refer to the datasheet for the full list
112 #define ABRT_7B_ADDR_NOACK 0
113 #define ABRT_10ADDR1_NOACK 1
114 #define ABRT_10ADDR2_NOACK 2
115 #define ABRT_TXDATA_NOACK 3
116 #define ABRT_GCALL_NOACK 4
117 #define ABRT_GCALL_READ 5
118 #define ABRT_SBYTE_ACKDET 7
119 #define ABRT_SBYTE_NORSTRT 9
120 #define ABRT_10B_RD_NORSTRT 10
121 #define ARB_MASTER_DIS 11
124 static char *abort_sources[] = {
125 [ABRT_7B_ADDR_NOACK] =
126 "slave address not acknowledged (7bit mode)",
127 [ABRT_10ADDR1_NOACK] =
128 "first address byte not acknowledged (10bit mode)",
129 [ABRT_10ADDR2_NOACK] =
130 "second address byte not acknowledged (10bit mode)",
131 [ABRT_TXDATA_NOACK] =
132 "data not acknowledged",
134 "no acknowledgement for a general call",
136 "read after general call",
137 [ABRT_SBYTE_ACKDET] =
138 "start byte acknowledged",
139 [ABRT_SBYTE_NORSTRT] =
140 "trying to send start byte when restart is disabled",
141 [ABRT_10B_RD_NORSTRT] =
142 "trying to read when restart is disabled (10bit mode)",
144 "trying to use disabled adapter",
150 * struct dw_i2c_dev - private i2c-designware data
151 * @dev: driver model device node
152 * @base: IO registers pointer
153 * @cmd_complete: tx completion indicator
154 * @lock: protect this struct and IO registers
155 * @clk: input reference clock
156 * @cmd_err: run time hadware error code
157 * @msgs: points to an array of messages currently being transfered
158 * @msgs_num: the number of elements in msgs
159 * @msg_write_idx: the element index of the current tx message in the msgs
161 * @tx_buf_len: the length of the current tx buffer
162 * @tx_buf: the current tx buffer
163 * @msg_read_idx: the element index of the current rx message in the msgs
165 * @rx_buf_len: the length of the current rx buffer
166 * @rx_buf: the current rx buffer
167 * @msg_err: error status of the current transfer
168 * @status: i2c master status, one of STATUS_*
169 * @abort_source: copy of the TX_ABRT_SOURCE register
170 * @irq: interrupt number for the i2c master
171 * @adapter: i2c subsystem adapter node
172 * @tx_fifo_depth: depth of the hardware tx fifo
173 * @rx_fifo_depth: depth of the hardware rx fifo
178 struct completion cmd_complete;
182 struct i2c_msg *msgs;
194 struct i2c_adapter adapter;
195 unsigned int tx_fifo_depth;
196 unsigned int rx_fifo_depth;
200 i2c_dw_scl_hcnt(u32 ic_clk, u32 tSYMBOL, u32 tf, int cond, int offset)
203 * DesignWare I2C core doesn't seem to have solid strategy to meet
204 * the tHD;STA timing spec. Configuring _HCNT based on tHIGH spec
205 * will result in violation of the tHD;STA spec.
209 * Conditional expression:
211 * IC_[FS]S_SCL_HCNT + (1+4+3) >= IC_CLK * tHIGH
213 * This is based on the DW manuals, and represents an ideal
214 * configuration. The resulting I2C bus speed will be
215 * faster than any of the others.
217 * If your hardware is free from tHD;STA issue, try this one.
219 return (ic_clk * tSYMBOL + 5000) / 10000 - 8 + offset;
222 * Conditional expression:
224 * IC_[FS]S_SCL_HCNT + 3 >= IC_CLK * (tHD;STA + tf)
226 * This is just experimental rule; the tHD;STA period turned
227 * out to be proportinal to (_HCNT + 3). With this setting,
228 * we could meet both tHIGH and tHD;STA timing specs.
230 * If unsure, you'd better to take this alternative.
232 * The reason why we need to take into account "tf" here,
233 * is the same as described in i2c_dw_scl_lcnt().
235 return (ic_clk * (tSYMBOL + tf) + 5000) / 10000 - 3 + offset;
238 static u32 i2c_dw_scl_lcnt(u32 ic_clk, u32 tLOW, u32 tf, int offset)
241 * Conditional expression:
243 * IC_[FS]S_SCL_LCNT + 1 >= IC_CLK * (tLOW + tf)
245 * DW I2C core starts counting the SCL CNTs for the LOW period
246 * of the SCL clock (tLOW) as soon as it pulls the SCL line.
247 * In order to meet the tLOW timing spec, we need to take into
248 * account the fall time of SCL signal (tf). Default tf value
249 * should be 0.3 us, for safety.
251 return ((ic_clk * (tLOW + tf) + 5000) / 10000) - 1 + offset;
255 * i2c_dw_init() - initialize the designware i2c master hardware
256 * @dev: device private data
258 * This functions configures and enables the I2C master.
259 * This function is called during I2C init function, and in case of timeout at
262 static void i2c_dw_init(struct dw_i2c_dev *dev)
264 u32 input_clock_khz = clk_get_rate(dev->clk) / 1000;
265 u32 ic_con, hcnt, lcnt;
267 /* Disable the adapter */
268 writel(0, dev->base + DW_IC_ENABLE);
270 /* set standard and fast speed deviders for high/low periods */
273 hcnt = i2c_dw_scl_hcnt(input_clock_khz,
274 40, /* tHD;STA = tHIGH = 4.0 us */
276 0, /* 0: DW default, 1: Ideal */
278 lcnt = i2c_dw_scl_lcnt(input_clock_khz,
279 47, /* tLOW = 4.7 us */
282 writel(hcnt, dev->base + DW_IC_SS_SCL_HCNT);
283 writel(lcnt, dev->base + DW_IC_SS_SCL_LCNT);
284 dev_dbg(dev->dev, "Standard-mode HCNT:LCNT = %d:%d\n", hcnt, lcnt);
287 hcnt = i2c_dw_scl_hcnt(input_clock_khz,
288 6, /* tHD;STA = tHIGH = 0.6 us */
290 0, /* 0: DW default, 1: Ideal */
292 lcnt = i2c_dw_scl_lcnt(input_clock_khz,
293 13, /* tLOW = 1.3 us */
296 writel(hcnt, dev->base + DW_IC_FS_SCL_HCNT);
297 writel(lcnt, dev->base + DW_IC_FS_SCL_LCNT);
298 dev_dbg(dev->dev, "Fast-mode HCNT:LCNT = %d:%d\n", hcnt, lcnt);
300 /* Configure Tx/Rx FIFO threshold levels */
301 writel(dev->tx_fifo_depth - 1, dev->base + DW_IC_TX_TL);
302 writel(0, dev->base + DW_IC_RX_TL);
304 /* configure the i2c master */
305 ic_con = DW_IC_CON_MASTER | DW_IC_CON_SLAVE_DISABLE |
306 DW_IC_CON_RESTART_EN | DW_IC_CON_SPEED_FAST;
307 writel(ic_con, dev->base + DW_IC_CON);
311 * Waiting for bus not busy
313 static int i2c_dw_wait_bus_not_busy(struct dw_i2c_dev *dev)
315 int timeout = TIMEOUT;
317 while (readl(dev->base + DW_IC_STATUS) & DW_IC_STATUS_ACTIVITY) {
319 dev_warn(dev->dev, "timeout waiting for bus ready\n");
330 * Initiate low level master read/write transaction.
331 * This function is called from i2c_dw_xfer when starting a transfer.
332 * This function is also called from i2c_dw_isr to continue a transfer
333 * that is longer than the size of the TX FIFO.
336 i2c_dw_xfer_msg(struct dw_i2c_dev *dev)
338 struct i2c_msg *msgs = dev->msgs;
339 u32 ic_con, intr_mask;
340 int tx_limit = dev->tx_fifo_depth - readl(dev->base + DW_IC_TXFLR);
341 int rx_limit = dev->rx_fifo_depth - readl(dev->base + DW_IC_RXFLR);
342 u32 addr = msgs[dev->msg_write_idx].addr;
343 u32 buf_len = dev->tx_buf_len;
345 intr_mask = DW_IC_INTR_STOP_DET | DW_IC_INTR_TX_ABRT | DW_IC_INTR_RX_FULL;
347 if (!(dev->status & STATUS_WRITE_IN_PROGRESS)) {
348 /* Disable the adapter */
349 writel(0, dev->base + DW_IC_ENABLE);
351 /* set the slave (target) address */
352 writel(msgs[dev->msg_write_idx].addr, dev->base + DW_IC_TAR);
354 /* if the slave address is ten bit address, enable 10BITADDR */
355 ic_con = readl(dev->base + DW_IC_CON);
356 if (msgs[dev->msg_write_idx].flags & I2C_M_TEN)
357 ic_con |= DW_IC_CON_10BITADDR_MASTER;
359 ic_con &= ~DW_IC_CON_10BITADDR_MASTER;
360 writel(ic_con, dev->base + DW_IC_CON);
362 /* Enable the adapter */
363 writel(1, dev->base + DW_IC_ENABLE);
366 for (; dev->msg_write_idx < dev->msgs_num; dev->msg_write_idx++) {
367 /* if target address has changed, we need to
368 * reprogram the target address in the i2c
369 * adapter when we are done with this transfer
371 if (msgs[dev->msg_write_idx].addr != addr)
374 if (msgs[dev->msg_write_idx].len == 0) {
376 "%s: invalid message length\n", __func__);
377 dev->msg_err = -EINVAL;
381 if (!(dev->status & STATUS_WRITE_IN_PROGRESS)) {
383 dev->tx_buf = msgs[dev->msg_write_idx].buf;
384 buf_len = msgs[dev->msg_write_idx].len;
387 while (buf_len > 0 && tx_limit > 0 && rx_limit > 0) {
388 if (msgs[dev->msg_write_idx].flags & I2C_M_RD) {
389 writel(0x100, dev->base + DW_IC_DATA_CMD);
392 writel(*(dev->tx_buf++),
393 dev->base + DW_IC_DATA_CMD);
394 tx_limit--; buf_len--;
397 dev->tx_buf_len = buf_len;
400 /* more bytes to be written */
401 intr_mask |= DW_IC_INTR_TX_EMPTY;
402 dev->status |= STATUS_WRITE_IN_PROGRESS;
405 dev->status &= ~STATUS_WRITE_IN_PROGRESS;
408 writel(intr_mask, dev->base + DW_IC_INTR_MASK);
412 i2c_dw_read(struct dw_i2c_dev *dev)
414 struct i2c_msg *msgs = dev->msgs;
415 u32 addr = msgs[dev->msg_read_idx].addr;
416 int rx_valid = readl(dev->base + DW_IC_RXFLR);
418 for (; dev->msg_read_idx < dev->msgs_num; dev->msg_read_idx++) {
422 if (!(msgs[dev->msg_read_idx].flags & I2C_M_RD))
425 /* different i2c client, reprogram the i2c adapter */
426 if (msgs[dev->msg_read_idx].addr != addr)
429 if (!(dev->status & STATUS_READ_IN_PROGRESS)) {
430 len = msgs[dev->msg_read_idx].len;
431 buf = msgs[dev->msg_read_idx].buf;
433 len = dev->rx_buf_len;
437 for (; len > 0 && rx_valid > 0; len--, rx_valid--)
438 *buf++ = readl(dev->base + DW_IC_DATA_CMD);
441 dev->status |= STATUS_READ_IN_PROGRESS;
442 dev->rx_buf_len = len;
446 dev->status &= ~STATUS_READ_IN_PROGRESS;
451 * Prepare controller for a transaction and call i2c_dw_xfer_msg
454 i2c_dw_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num)
456 struct dw_i2c_dev *dev = i2c_get_adapdata(adap);
459 dev_dbg(dev->dev, "%s: msgs: %d\n", __func__, num);
461 mutex_lock(&dev->lock);
463 INIT_COMPLETION(dev->cmd_complete);
467 dev->msg_write_idx = 0;
468 dev->msg_read_idx = 0;
470 dev->status = STATUS_IDLE;
472 ret = i2c_dw_wait_bus_not_busy(dev);
476 /* start the transfers */
477 i2c_dw_xfer_msg(dev);
479 /* wait for tx to complete */
480 ret = wait_for_completion_interruptible_timeout(&dev->cmd_complete, HZ);
482 dev_err(dev->dev, "controller timed out\n");
495 if (likely(!dev->cmd_err)) {
496 /* Disable the adapter */
497 writel(0, dev->base + DW_IC_ENABLE);
502 /* We have an error */
503 if (dev->cmd_err == DW_IC_ERR_TX_ABRT) {
504 unsigned long abort_source = dev->abort_source;
507 for_each_bit(i, &abort_source, ARRAY_SIZE(abort_sources)) {
508 dev_err(dev->dev, "%s: %s\n", __func__, abort_sources[i]);
514 mutex_unlock(&dev->lock);
519 static u32 i2c_dw_func(struct i2c_adapter *adap)
521 return I2C_FUNC_I2C | I2C_FUNC_10BIT_ADDR;
524 static u32 i2c_dw_read_clear_intrbits(struct dw_i2c_dev *dev)
529 * The IC_INTR_STAT register just indicates "enabled" interrupts.
530 * Ths unmasked raw version of interrupt status bits are available
531 * in the IC_RAW_INTR_STAT register.
534 * stat = readl(IC_INTR_STAT);
536 * stat = readl(IC_RAW_INTR_STAT) & readl(IC_INTR_MASK);
538 * The raw version might be useful for debugging purposes.
540 stat = readl(dev->base + DW_IC_INTR_STAT);
543 * Do not use the IC_CLR_INTR register to clear interrupts, or
544 * you'll miss some interrupts, triggered during the period from
545 * readl(IC_INTR_STAT) to readl(IC_CLR_INTR).
547 * Instead, use the separately-prepared IC_CLR_* registers.
549 if (stat & DW_IC_INTR_RX_UNDER)
550 readl(dev->base + DW_IC_CLR_RX_UNDER);
551 if (stat & DW_IC_INTR_RX_OVER)
552 readl(dev->base + DW_IC_CLR_RX_OVER);
553 if (stat & DW_IC_INTR_TX_OVER)
554 readl(dev->base + DW_IC_CLR_TX_OVER);
555 if (stat & DW_IC_INTR_RD_REQ)
556 readl(dev->base + DW_IC_CLR_RD_REQ);
557 if (stat & DW_IC_INTR_TX_ABRT) {
559 * The IC_TX_ABRT_SOURCE register is cleared whenever
560 * the IC_CLR_TX_ABRT is read. Preserve it beforehand.
562 dev->abort_source = readl(dev->base + DW_IC_TX_ABRT_SOURCE);
563 readl(dev->base + DW_IC_CLR_TX_ABRT);
565 if (stat & DW_IC_INTR_RX_DONE)
566 readl(dev->base + DW_IC_CLR_RX_DONE);
567 if (stat & DW_IC_INTR_ACTIVITY)
568 readl(dev->base + DW_IC_CLR_ACTIVITY);
569 if (stat & DW_IC_INTR_STOP_DET)
570 readl(dev->base + DW_IC_CLR_STOP_DET);
571 if (stat & DW_IC_INTR_START_DET)
572 readl(dev->base + DW_IC_CLR_START_DET);
573 if (stat & DW_IC_INTR_GEN_CALL)
574 readl(dev->base + DW_IC_CLR_GEN_CALL);
580 * Interrupt service routine. This gets called whenever an I2C interrupt
583 static irqreturn_t i2c_dw_isr(int this_irq, void *dev_id)
585 struct dw_i2c_dev *dev = dev_id;
588 stat = i2c_dw_read_clear_intrbits(dev);
589 dev_dbg(dev->dev, "%s: stat=0x%x\n", __func__, stat);
591 if (stat & DW_IC_INTR_TX_ABRT) {
592 dev->cmd_err |= DW_IC_ERR_TX_ABRT;
593 dev->status = STATUS_IDLE;
596 if (stat & DW_IC_INTR_RX_FULL)
599 if (stat & DW_IC_INTR_TX_EMPTY)
600 i2c_dw_xfer_msg(dev);
603 * No need to modify or disable the interrupt mask here.
604 * i2c_dw_xfer_msg() will take care of it according to
605 * the current transmit status.
608 if (stat & (DW_IC_INTR_TX_ABRT | DW_IC_INTR_STOP_DET))
609 complete(&dev->cmd_complete);
614 static struct i2c_algorithm i2c_dw_algo = {
615 .master_xfer = i2c_dw_xfer,
616 .functionality = i2c_dw_func,
619 static int __devinit dw_i2c_probe(struct platform_device *pdev)
621 struct dw_i2c_dev *dev;
622 struct i2c_adapter *adap;
623 struct resource *mem, *ioarea;
626 /* NOTE: driver uses the static register mapping */
627 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
629 dev_err(&pdev->dev, "no mem resource?\n");
633 irq = platform_get_irq(pdev, 0);
635 dev_err(&pdev->dev, "no irq resource?\n");
636 return irq; /* -ENXIO */
639 ioarea = request_mem_region(mem->start, resource_size(mem),
642 dev_err(&pdev->dev, "I2C region already claimed\n");
646 dev = kzalloc(sizeof(struct dw_i2c_dev), GFP_KERNEL);
649 goto err_release_region;
652 init_completion(&dev->cmd_complete);
653 mutex_init(&dev->lock);
654 dev->dev = get_device(&pdev->dev);
656 platform_set_drvdata(pdev, dev);
658 dev->clk = clk_get(&pdev->dev, NULL);
659 if (IS_ERR(dev->clk)) {
663 clk_enable(dev->clk);
665 dev->base = ioremap(mem->start, resource_size(mem));
666 if (dev->base == NULL) {
667 dev_err(&pdev->dev, "failure mapping io resources\n");
669 goto err_unuse_clocks;
672 u32 param1 = readl(dev->base + DW_IC_COMP_PARAM_1);
674 dev->tx_fifo_depth = ((param1 >> 16) & 0xff) + 1;
675 dev->rx_fifo_depth = ((param1 >> 8) & 0xff) + 1;
679 writel(0, dev->base + DW_IC_INTR_MASK); /* disable IRQ */
680 r = request_irq(dev->irq, i2c_dw_isr, 0, pdev->name, dev);
682 dev_err(&pdev->dev, "failure requesting irq %i\n", dev->irq);
686 adap = &dev->adapter;
687 i2c_set_adapdata(adap, dev);
688 adap->owner = THIS_MODULE;
689 adap->class = I2C_CLASS_HWMON;
690 strlcpy(adap->name, "Synopsys DesignWare I2C adapter",
692 adap->algo = &i2c_dw_algo;
693 adap->dev.parent = &pdev->dev;
696 r = i2c_add_numbered_adapter(adap);
698 dev_err(&pdev->dev, "failure adding adapter\n");
705 free_irq(dev->irq, dev);
709 clk_disable(dev->clk);
713 platform_set_drvdata(pdev, NULL);
714 put_device(&pdev->dev);
717 release_mem_region(mem->start, resource_size(mem));
722 static int __devexit dw_i2c_remove(struct platform_device *pdev)
724 struct dw_i2c_dev *dev = platform_get_drvdata(pdev);
725 struct resource *mem;
727 platform_set_drvdata(pdev, NULL);
728 i2c_del_adapter(&dev->adapter);
729 put_device(&pdev->dev);
731 clk_disable(dev->clk);
735 writel(0, dev->base + DW_IC_ENABLE);
736 free_irq(dev->irq, dev);
739 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
740 release_mem_region(mem->start, resource_size(mem));
744 /* work with hotplug and coldplug */
745 MODULE_ALIAS("platform:i2c_designware");
747 static struct platform_driver dw_i2c_driver = {
748 .remove = __devexit_p(dw_i2c_remove),
750 .name = "i2c_designware",
751 .owner = THIS_MODULE,
755 static int __init dw_i2c_init_driver(void)
757 return platform_driver_probe(&dw_i2c_driver, dw_i2c_probe);
759 module_init(dw_i2c_init_driver);
761 static void __exit dw_i2c_exit_driver(void)
763 platform_driver_unregister(&dw_i2c_driver);
765 module_exit(dw_i2c_exit_driver);
767 MODULE_AUTHOR("Baruch Siach <baruch@tkos.co.il>");
768 MODULE_DESCRIPTION("Synopsys DesignWare I2C bus adapter");
769 MODULE_LICENSE("GPL");