blob: e828a1dba0e5a5d4cafdcfaf4c1188df89f04b1a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* linux/drivers/i2c/busses/i2c-s3c2410.c
2 *
Daniel Silverstonec564e6a2009-03-13 13:53:46 +00003 * Copyright (C) 2004,2005,2009 Simtec Electronics
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 * Ben Dooks <ben@simtec.co.uk>
5 *
6 * S3C2410 I2C Controller
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21*/
22
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/kernel.h>
24#include <linux/module.h>
25
26#include <linux/i2c.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/init.h>
28#include <linux/time.h>
29#include <linux/interrupt.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/delay.h>
31#include <linux/errno.h>
32#include <linux/err.h>
Russell Kingd052d1b2005-10-29 19:07:23 +010033#include <linux/platform_device.h>
Mark Brownc62c3ca2012-01-21 13:28:47 +000034#include <linux/pm_runtime.h>
Russell Kingf8ce2542006-01-07 16:15:52 +000035#include <linux/clk.h>
Ben Dooks61c7cff2008-07-28 12:04:07 +010036#include <linux/cpufreq.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090037#include <linux/slab.h>
H Hartley Sweeten21782182010-05-21 18:41:01 +020038#include <linux/io.h>
Sachin Kamat4edd65e2013-10-16 15:26:33 +053039#include <linux/of.h>
Thomas Abraham5a5f5082011-09-13 09:46:05 +053040#include <linux/of_gpio.h>
Tomasz Figa2693ac62012-11-13 11:33:40 +010041#include <linux/pinctrl/consumer.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <asm/irq.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
Arnd Bergmann436d42c2012-08-24 15:22:12 +020045#include <linux/platform_data/i2c-s3c2410.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
Heiko Stübnere6366022013-03-21 04:09:25 +000047/* see s3c2410x user guide, v1.1, section 9 (p447) for more info */
48
Heiko Stübner7a6674d2013-03-21 04:10:13 +000049#define S3C2410_IICCON 0x00
50#define S3C2410_IICSTAT 0x04
51#define S3C2410_IICADD 0x08
52#define S3C2410_IICDS 0x0C
53#define S3C2440_IICLC 0x10
Heiko Stübnere6366022013-03-21 04:09:25 +000054
Heiko Stübner7a6674d2013-03-21 04:10:13 +000055#define S3C2410_IICCON_ACKEN (1 << 7)
56#define S3C2410_IICCON_TXDIV_16 (0 << 6)
57#define S3C2410_IICCON_TXDIV_512 (1 << 6)
58#define S3C2410_IICCON_IRQEN (1 << 5)
59#define S3C2410_IICCON_IRQPEND (1 << 4)
60#define S3C2410_IICCON_SCALE(x) ((x) & 0xf)
Heiko Stübnere6366022013-03-21 04:09:25 +000061#define S3C2410_IICCON_SCALEMASK (0xf)
62
Heiko Stübner7a6674d2013-03-21 04:10:13 +000063#define S3C2410_IICSTAT_MASTER_RX (2 << 6)
64#define S3C2410_IICSTAT_MASTER_TX (3 << 6)
65#define S3C2410_IICSTAT_SLAVE_RX (0 << 6)
66#define S3C2410_IICSTAT_SLAVE_TX (1 << 6)
67#define S3C2410_IICSTAT_MODEMASK (3 << 6)
Heiko Stübnere6366022013-03-21 04:09:25 +000068
Heiko Stübner7a6674d2013-03-21 04:10:13 +000069#define S3C2410_IICSTAT_START (1 << 5)
70#define S3C2410_IICSTAT_BUSBUSY (1 << 5)
71#define S3C2410_IICSTAT_TXRXEN (1 << 4)
72#define S3C2410_IICSTAT_ARBITR (1 << 3)
73#define S3C2410_IICSTAT_ASSLAVE (1 << 2)
74#define S3C2410_IICSTAT_ADDR0 (1 << 1)
75#define S3C2410_IICSTAT_LASTBIT (1 << 0)
Heiko Stübnere6366022013-03-21 04:09:25 +000076
77#define S3C2410_IICLC_SDA_DELAY0 (0 << 0)
78#define S3C2410_IICLC_SDA_DELAY5 (1 << 0)
79#define S3C2410_IICLC_SDA_DELAY10 (2 << 0)
80#define S3C2410_IICLC_SDA_DELAY15 (3 << 0)
81#define S3C2410_IICLC_SDA_DELAY_MASK (3 << 0)
82
Heiko Stübner7a6674d2013-03-21 04:10:13 +000083#define S3C2410_IICLC_FILTER_ON (1 << 2)
Heiko Stübnere6366022013-03-21 04:09:25 +000084
Karol Lewandowski27452492012-04-23 18:24:00 +020085/* Treat S3C2410 as baseline hardware, anything else is supported via quirks */
86#define QUIRK_S3C2440 (1 << 0)
Karol Lewandowskiec39ef82012-04-23 18:24:01 +020087#define QUIRK_HDMIPHY (1 << 1)
88#define QUIRK_NO_GPIO (1 << 2)
Vasanth Ananthan117053f2013-11-11 16:50:20 +053089#define QUIRK_POLL (1 << 3)
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
Daniel Kurtzfe724bf2012-11-15 17:43:32 +053091/* Max time to wait for bus to become idle after a xfer (in us) */
92#define S3C2410_IDLE_TIMEOUT 5000
93
Karol Lewandowski27452492012-04-23 18:24:00 +020094/* i2c controller state */
Linus Torvalds1da177e2005-04-16 15:20:36 -070095enum s3c24xx_i2c_state {
96 STATE_IDLE,
97 STATE_START,
98 STATE_READ,
99 STATE_WRITE,
100 STATE_STOP
101};
102
103struct s3c24xx_i2c {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 wait_queue_head_t wait;
Pankaj Dubey5f1b1152014-01-15 10:42:42 +0900105 kernel_ulong_t quirks;
Ben Dooksbe44f012008-10-31 16:10:22 +0000106 unsigned int suspended:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107
108 struct i2c_msg *msg;
109 unsigned int msg_num;
110 unsigned int msg_idx;
111 unsigned int msg_ptr;
112
Ben Dookse00a8cd2007-05-01 23:26:35 +0200113 unsigned int tx_setup;
Ben Dookse0d1ec92008-10-31 16:10:30 +0000114 unsigned int irq;
Ben Dookse00a8cd2007-05-01 23:26:35 +0200115
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 enum s3c24xx_i2c_state state;
Ben Dooks61c7cff2008-07-28 12:04:07 +0100117 unsigned long clkrate;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118
119 void __iomem *regs;
120 struct clk *clk;
121 struct device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 struct i2c_adapter adap;
Ben Dooks61c7cff2008-07-28 12:04:07 +0100123
Thomas Abraham4fd81eb2011-09-13 09:46:04 +0530124 struct s3c2410_platform_i2c *pdata;
Thomas Abraham5a5f5082011-09-13 09:46:05 +0530125 int gpios[2];
Tomasz Figa2693ac62012-11-13 11:33:40 +0100126 struct pinctrl *pctrl;
Naveen Krishna Ch61f4d6b2013-11-26 09:52:46 +0530127#if defined(CONFIG_ARM_S3C24XX_CPUFREQ)
Ben Dooks61c7cff2008-07-28 12:04:07 +0100128 struct notifier_block freq_transition;
129#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130};
131
Karol Lewandowski27452492012-04-23 18:24:00 +0200132static struct platform_device_id s3c24xx_driver_ids[] = {
133 {
134 .name = "s3c2410-i2c",
135 .driver_data = 0,
136 }, {
137 .name = "s3c2440-i2c",
138 .driver_data = QUIRK_S3C2440,
Karol Lewandowskiec39ef82012-04-23 18:24:01 +0200139 }, {
140 .name = "s3c2440-hdmiphy-i2c",
141 .driver_data = QUIRK_S3C2440 | QUIRK_HDMIPHY | QUIRK_NO_GPIO,
Karol Lewandowski27452492012-04-23 18:24:00 +0200142 }, { },
143};
144MODULE_DEVICE_TABLE(platform, s3c24xx_driver_ids);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145
Vasanth Ananthan117053f2013-11-11 16:50:20 +0530146static int i2c_s3c_irq_nextbyte(struct s3c24xx_i2c *i2c, unsigned long iicstat);
147
Thomas Abraham5a5f5082011-09-13 09:46:05 +0530148#ifdef CONFIG_OF
Karol Lewandowski27452492012-04-23 18:24:00 +0200149static const struct of_device_id s3c24xx_i2c_match[] = {
150 { .compatible = "samsung,s3c2410-i2c", .data = (void *)0 },
151 { .compatible = "samsung,s3c2440-i2c", .data = (void *)QUIRK_S3C2440 },
Karol Lewandowskiec39ef82012-04-23 18:24:01 +0200152 { .compatible = "samsung,s3c2440-hdmiphy-i2c",
153 .data = (void *)(QUIRK_S3C2440 | QUIRK_HDMIPHY | QUIRK_NO_GPIO) },
Giridhar Maruthyfaf93ff2013-01-24 11:27:51 -0800154 { .compatible = "samsung,exynos5440-i2c",
155 .data = (void *)(QUIRK_S3C2440 | QUIRK_NO_GPIO) },
Vasanth Ananthan117053f2013-11-11 16:50:20 +0530156 { .compatible = "samsung,exynos5-sata-phy-i2c",
157 .data = (void *)(QUIRK_S3C2440 | QUIRK_POLL | QUIRK_NO_GPIO) },
Karol Lewandowski27452492012-04-23 18:24:00 +0200158 {},
159};
160MODULE_DEVICE_TABLE(of, s3c24xx_i2c_match);
Thomas Abraham5a5f5082011-09-13 09:46:05 +0530161#endif
162
Karol Lewandowski27452492012-04-23 18:24:00 +0200163/* s3c24xx_get_device_quirks
164 *
165 * Get controller type either from device tree or platform device variant.
166*/
167
Pankaj Dubey5f1b1152014-01-15 10:42:42 +0900168static inline kernel_ulong_t s3c24xx_get_device_quirks(struct platform_device *pdev)
Karol Lewandowski27452492012-04-23 18:24:00 +0200169{
170 if (pdev->dev.of_node) {
171 const struct of_device_id *match;
Karol Lewandowskib900ba42012-05-30 11:43:05 +0200172 match = of_match_node(s3c24xx_i2c_match, pdev->dev.of_node);
Pankaj Dubey5f1b1152014-01-15 10:42:42 +0900173 return (kernel_ulong_t)match->data;
Karol Lewandowski27452492012-04-23 18:24:00 +0200174 }
175
176 return platform_get_device_id(pdev)->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177}
178
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179/* s3c24xx_i2c_master_complete
180 *
181 * complete the message and wake up the caller, using the given return code,
182 * or zero to mean ok.
183*/
184
185static inline void s3c24xx_i2c_master_complete(struct s3c24xx_i2c *i2c, int ret)
186{
187 dev_dbg(i2c->dev, "master_complete %d\n", ret);
188
189 i2c->msg_ptr = 0;
190 i2c->msg = NULL;
Ben Dooks3d0911b2008-10-31 16:10:24 +0000191 i2c->msg_idx++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 i2c->msg_num = 0;
193 if (ret)
194 i2c->msg_idx = ret;
195
Vasanth Ananthan117053f2013-11-11 16:50:20 +0530196 if (!(i2c->quirks & QUIRK_POLL))
197 wake_up(&i2c->wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198}
199
200static inline void s3c24xx_i2c_disable_ack(struct s3c24xx_i2c *i2c)
201{
202 unsigned long tmp;
Ben Dooks3d0911b2008-10-31 16:10:24 +0000203
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 tmp = readl(i2c->regs + S3C2410_IICCON);
205 writel(tmp & ~S3C2410_IICCON_ACKEN, i2c->regs + S3C2410_IICCON);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206}
207
208static inline void s3c24xx_i2c_enable_ack(struct s3c24xx_i2c *i2c)
209{
210 unsigned long tmp;
Ben Dooks3d0911b2008-10-31 16:10:24 +0000211
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 tmp = readl(i2c->regs + S3C2410_IICCON);
213 writel(tmp | S3C2410_IICCON_ACKEN, i2c->regs + S3C2410_IICCON);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214}
215
216/* irq enable/disable functions */
217
218static inline void s3c24xx_i2c_disable_irq(struct s3c24xx_i2c *i2c)
219{
220 unsigned long tmp;
Ben Dooks3d0911b2008-10-31 16:10:24 +0000221
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 tmp = readl(i2c->regs + S3C2410_IICCON);
223 writel(tmp & ~S3C2410_IICCON_IRQEN, i2c->regs + S3C2410_IICCON);
224}
225
226static inline void s3c24xx_i2c_enable_irq(struct s3c24xx_i2c *i2c)
227{
228 unsigned long tmp;
Ben Dooks3d0911b2008-10-31 16:10:24 +0000229
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 tmp = readl(i2c->regs + S3C2410_IICCON);
231 writel(tmp | S3C2410_IICCON_IRQEN, i2c->regs + S3C2410_IICCON);
232}
233
Vasanth Ananthan117053f2013-11-11 16:50:20 +0530234static bool is_ack(struct s3c24xx_i2c *i2c)
235{
236 int tries;
237
238 for (tries = 50; tries; --tries) {
239 if (readl(i2c->regs + S3C2410_IICCON)
240 & S3C2410_IICCON_IRQPEND) {
241 if (!(readl(i2c->regs + S3C2410_IICSTAT)
242 & S3C2410_IICSTAT_LASTBIT))
243 return true;
244 }
245 usleep_range(1000, 2000);
246 }
247 dev_err(i2c->dev, "ack was not recieved\n");
248 return false;
249}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250
251/* s3c24xx_i2c_message_start
252 *
Ben Dooks3d0911b2008-10-31 16:10:24 +0000253 * put the start of a message onto the bus
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254*/
255
Ben Dooks3d0911b2008-10-31 16:10:24 +0000256static void s3c24xx_i2c_message_start(struct s3c24xx_i2c *i2c,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 struct i2c_msg *msg)
258{
259 unsigned int addr = (msg->addr & 0x7f) << 1;
260 unsigned long stat;
261 unsigned long iiccon;
262
263 stat = 0;
264 stat |= S3C2410_IICSTAT_TXRXEN;
265
266 if (msg->flags & I2C_M_RD) {
267 stat |= S3C2410_IICSTAT_MASTER_RX;
268 addr |= 1;
269 } else
270 stat |= S3C2410_IICSTAT_MASTER_TX;
271
272 if (msg->flags & I2C_M_REV_DIR_ADDR)
273 addr ^= 1;
274
Adam Buchbinder48fc7f72012-09-19 21:48:00 -0400275 /* todo - check for whether ack wanted or not */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 s3c24xx_i2c_enable_ack(i2c);
277
278 iiccon = readl(i2c->regs + S3C2410_IICCON);
279 writel(stat, i2c->regs + S3C2410_IICSTAT);
Ben Dooks3d0911b2008-10-31 16:10:24 +0000280
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 dev_dbg(i2c->dev, "START: %08lx to IICSTAT, %02x to DS\n", stat, addr);
282 writeb(addr, i2c->regs + S3C2410_IICDS);
Ben Dooks3d0911b2008-10-31 16:10:24 +0000283
Ben Dookse00a8cd2007-05-01 23:26:35 +0200284 /* delay here to ensure the data byte has gotten onto the bus
285 * before the transaction is started */
286
287 ndelay(i2c->tx_setup);
288
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 dev_dbg(i2c->dev, "iiccon, %08lx\n", iiccon);
290 writel(iiccon, i2c->regs + S3C2410_IICCON);
Ben Dooks3d0911b2008-10-31 16:10:24 +0000291
292 stat |= S3C2410_IICSTAT_START;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 writel(stat, i2c->regs + S3C2410_IICSTAT);
Vasanth Ananthan117053f2013-11-11 16:50:20 +0530294
295 if (i2c->quirks & QUIRK_POLL) {
296 while ((i2c->msg_num != 0) && is_ack(i2c)) {
297 i2c_s3c_irq_nextbyte(i2c, stat);
298 stat = readl(i2c->regs + S3C2410_IICSTAT);
299
300 if (stat & S3C2410_IICSTAT_ARBITR)
301 dev_err(i2c->dev, "deal with arbitration loss\n");
302 }
303 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304}
305
306static inline void s3c24xx_i2c_stop(struct s3c24xx_i2c *i2c, int ret)
307{
308 unsigned long iicstat = readl(i2c->regs + S3C2410_IICSTAT);
309
310 dev_dbg(i2c->dev, "STOP\n");
311
Daniel Kurtz0da2e772012-11-15 17:43:31 +0530312 /*
313 * The datasheet says that the STOP sequence should be:
314 * 1) I2CSTAT.5 = 0 - Clear BUSY (or 'generate STOP')
315 * 2) I2CCON.4 = 0 - Clear IRQPEND
316 * 3) Wait until the stop condition takes effect.
317 * 4*) I2CSTAT.4 = 0 - Clear TXRXEN
318 *
319 * Where, step "4*" is only for buses with the "HDMIPHY" quirk.
320 *
321 * However, after much experimentation, it appears that:
322 * a) normal buses automatically clear BUSY and transition from
323 * Master->Slave when they complete generating a STOP condition.
324 * Therefore, step (3) can be done in doxfer() by polling I2CCON.4
325 * after starting the STOP generation here.
326 * b) HDMIPHY bus does neither, so there is no way to do step 3.
327 * There is no indication when this bus has finished generating
328 * STOP.
329 *
330 * In fact, we have found that as soon as the IRQPEND bit is cleared in
331 * step 2, the HDMIPHY bus generates the STOP condition, and then
332 * immediately starts transferring another data byte, even though the
333 * bus is supposedly stopped. This is presumably because the bus is
334 * still in "Master" mode, and its BUSY bit is still set.
335 *
336 * To avoid these extra post-STOP transactions on HDMI phy devices, we
337 * just disable Serial Output on the bus (I2CSTAT.4 = 0) directly,
338 * instead of first generating a proper STOP condition. This should
339 * float SDA & SCK terminating the transfer. Subsequent transfers
340 * start with a proper START condition, and proceed normally.
341 *
342 * The HDMIPHY bus is an internal bus that always has exactly two
343 * devices, the host as Master and the HDMIPHY device as the slave.
344 * Skipping the STOP condition has been tested on this bus and works.
345 */
346 if (i2c->quirks & QUIRK_HDMIPHY) {
347 /* Stop driving the I2C pins */
348 iicstat &= ~S3C2410_IICSTAT_TXRXEN;
349 } else {
350 /* stop the transfer */
351 iicstat &= ~S3C2410_IICSTAT_START;
352 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 writel(iicstat, i2c->regs + S3C2410_IICSTAT);
Ben Dooks3d0911b2008-10-31 16:10:24 +0000354
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 i2c->state = STATE_STOP;
Ben Dooks3d0911b2008-10-31 16:10:24 +0000356
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 s3c24xx_i2c_master_complete(i2c, ret);
358 s3c24xx_i2c_disable_irq(i2c);
359}
360
361/* helper functions to determine the current state in the set of
362 * messages we are sending */
363
364/* is_lastmsg()
365 *
Ben Dooks3d0911b2008-10-31 16:10:24 +0000366 * returns TRUE if the current message is the last in the set
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367*/
368
369static inline int is_lastmsg(struct s3c24xx_i2c *i2c)
370{
371 return i2c->msg_idx >= (i2c->msg_num - 1);
372}
373
374/* is_msglast
375 *
376 * returns TRUE if we this is the last byte in the current message
377*/
378
379static inline int is_msglast(struct s3c24xx_i2c *i2c)
380{
Jaemin Yoo857473112013-03-26 04:29:56 +0000381 /* msg->len is always 1 for the first byte of smbus block read.
382 * Actual length will be read from slave. More bytes will be
383 * read according to the length then. */
384 if (i2c->msg->flags & I2C_M_RECV_LEN && i2c->msg->len == 1)
385 return 0;
386
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 return i2c->msg_ptr == i2c->msg->len-1;
388}
389
390/* is_msgend
391 *
392 * returns TRUE if we reached the end of the current message
393*/
394
395static inline int is_msgend(struct s3c24xx_i2c *i2c)
396{
397 return i2c->msg_ptr >= i2c->msg->len;
398}
399
Huisung Kang19820512011-06-23 21:37:33 +0900400/* i2c_s3c_irq_nextbyte
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 *
402 * process an interrupt and work out what to do
403 */
404
Huisung Kang19820512011-06-23 21:37:33 +0900405static int i2c_s3c_irq_nextbyte(struct s3c24xx_i2c *i2c, unsigned long iicstat)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406{
407 unsigned long tmp;
408 unsigned char byte;
409 int ret = 0;
410
411 switch (i2c->state) {
412
413 case STATE_IDLE:
Harvey Harrison08882d22008-04-22 22:16:47 +0200414 dev_err(i2c->dev, "%s: called in STATE_IDLE\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416
417 case STATE_STOP:
Harvey Harrison08882d22008-04-22 22:16:47 +0200418 dev_err(i2c->dev, "%s: called in STATE_STOP\n", __func__);
Ben Dooks3d0911b2008-10-31 16:10:24 +0000419 s3c24xx_i2c_disable_irq(i2c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 goto out_ack;
421
422 case STATE_START:
423 /* last thing we did was send a start condition on the
424 * bus, or started a new i2c message
425 */
Ben Dooks3d0911b2008-10-31 16:10:24 +0000426
Ben Dooks63f5c282008-07-01 11:59:42 +0100427 if (iicstat & S3C2410_IICSTAT_LASTBIT &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 !(i2c->msg->flags & I2C_M_IGNORE_NAK)) {
429 /* ack was not received... */
430
431 dev_dbg(i2c->dev, "ack was not received\n");
Ben Dooks63f5c282008-07-01 11:59:42 +0100432 s3c24xx_i2c_stop(i2c, -ENXIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 goto out_ack;
434 }
435
436 if (i2c->msg->flags & I2C_M_RD)
437 i2c->state = STATE_READ;
438 else
439 i2c->state = STATE_WRITE;
440
441 /* terminate the transfer if there is nothing to do
Ben Dooks63f5c282008-07-01 11:59:42 +0100442 * as this is used by the i2c probe to find devices. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443
444 if (is_lastmsg(i2c) && i2c->msg->len == 0) {
445 s3c24xx_i2c_stop(i2c, 0);
446 goto out_ack;
447 }
448
449 if (i2c->state == STATE_READ)
450 goto prepare_read;
451
Ben Dooks3d0911b2008-10-31 16:10:24 +0000452 /* fall through to the write state, as we will need to
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 * send a byte as well */
454
455 case STATE_WRITE:
456 /* we are writing data to the device... check for the
457 * end of the message, and if so, work out what to do
458 */
459
Ben Dooks27097812008-07-01 11:59:41 +0100460 if (!(i2c->msg->flags & I2C_M_IGNORE_NAK)) {
461 if (iicstat & S3C2410_IICSTAT_LASTBIT) {
462 dev_dbg(i2c->dev, "WRITE: No Ack\n");
463
464 s3c24xx_i2c_stop(i2c, -ECONNREFUSED);
465 goto out_ack;
466 }
467 }
468
Ben Dooks3d0911b2008-10-31 16:10:24 +0000469 retry_write:
Ben Dooks27097812008-07-01 11:59:41 +0100470
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 if (!is_msgend(i2c)) {
472 byte = i2c->msg->buf[i2c->msg_ptr++];
473 writeb(byte, i2c->regs + S3C2410_IICDS);
Ben Dookse00a8cd2007-05-01 23:26:35 +0200474
475 /* delay after writing the byte to allow the
476 * data setup time on the bus, as writing the
477 * data to the register causes the first bit
478 * to appear on SDA, and SCL will change as
479 * soon as the interrupt is acknowledged */
480
481 ndelay(i2c->tx_setup);
482
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 } else if (!is_lastmsg(i2c)) {
484 /* we need to go to the next i2c message */
485
486 dev_dbg(i2c->dev, "WRITE: Next Message\n");
487
488 i2c->msg_ptr = 0;
Ben Dooks3d0911b2008-10-31 16:10:24 +0000489 i2c->msg_idx++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 i2c->msg++;
Ben Dooks3d0911b2008-10-31 16:10:24 +0000491
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 /* check to see if we need to do another message */
493 if (i2c->msg->flags & I2C_M_NOSTART) {
494
495 if (i2c->msg->flags & I2C_M_RD) {
496 /* cannot do this, the controller
497 * forces us to send a new START
498 * when we change direction */
499
500 s3c24xx_i2c_stop(i2c, -EINVAL);
501 }
502
503 goto retry_write;
504 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 /* send the new start */
506 s3c24xx_i2c_message_start(i2c, i2c->msg);
507 i2c->state = STATE_START;
508 }
509
510 } else {
511 /* send stop */
512
513 s3c24xx_i2c_stop(i2c, 0);
514 }
515 break;
516
517 case STATE_READ:
Ben Dooks3d0911b2008-10-31 16:10:24 +0000518 /* we have a byte of data in the data register, do
Adam Buchbinder48fc7f72012-09-19 21:48:00 -0400519 * something with it, and then work out whether we are
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 * going to do any more read/write
521 */
522
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 byte = readb(i2c->regs + S3C2410_IICDS);
524 i2c->msg->buf[i2c->msg_ptr++] = byte;
525
Jaemin Yoo857473112013-03-26 04:29:56 +0000526 /* Add actual length to read for smbus block read */
527 if (i2c->msg->flags & I2C_M_RECV_LEN && i2c->msg->len == 1)
528 i2c->msg->len += byte;
Ben Dooks3d0911b2008-10-31 16:10:24 +0000529 prepare_read:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 if (is_msglast(i2c)) {
531 /* last byte of buffer */
532
533 if (is_lastmsg(i2c))
534 s3c24xx_i2c_disable_ack(i2c);
Ben Dooks3d0911b2008-10-31 16:10:24 +0000535
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 } else if (is_msgend(i2c)) {
537 /* ok, we've read the entire buffer, see if there
538 * is anything else we need to do */
539
540 if (is_lastmsg(i2c)) {
541 /* last message, send stop and complete */
542 dev_dbg(i2c->dev, "READ: Send Stop\n");
543
544 s3c24xx_i2c_stop(i2c, 0);
545 } else {
546 /* go to the next transfer */
547 dev_dbg(i2c->dev, "READ: Next Transfer\n");
548
549 i2c->msg_ptr = 0;
550 i2c->msg_idx++;
551 i2c->msg++;
552 }
553 }
554
555 break;
556 }
557
558 /* acknowlegde the IRQ and get back on with the work */
559
560 out_ack:
Ben Dooks3d0911b2008-10-31 16:10:24 +0000561 tmp = readl(i2c->regs + S3C2410_IICCON);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 tmp &= ~S3C2410_IICCON_IRQPEND;
563 writel(tmp, i2c->regs + S3C2410_IICCON);
564 out:
565 return ret;
566}
567
568/* s3c24xx_i2c_irq
569 *
570 * top level IRQ servicing routine
571*/
572
David Howells7d12e782006-10-05 14:55:46 +0100573static irqreturn_t s3c24xx_i2c_irq(int irqno, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574{
575 struct s3c24xx_i2c *i2c = dev_id;
576 unsigned long status;
577 unsigned long tmp;
578
579 status = readl(i2c->regs + S3C2410_IICSTAT);
580
581 if (status & S3C2410_IICSTAT_ARBITR) {
Ben Dooks3d0911b2008-10-31 16:10:24 +0000582 /* deal with arbitration loss */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 dev_err(i2c->dev, "deal with arbitration loss\n");
584 }
585
586 if (i2c->state == STATE_IDLE) {
587 dev_dbg(i2c->dev, "IRQ: error i2c->state == IDLE\n");
588
Ben Dooks3d0911b2008-10-31 16:10:24 +0000589 tmp = readl(i2c->regs + S3C2410_IICCON);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 tmp &= ~S3C2410_IICCON_IRQPEND;
591 writel(tmp, i2c->regs + S3C2410_IICCON);
592 goto out;
593 }
Ben Dooks3d0911b2008-10-31 16:10:24 +0000594
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 /* pretty much this leaves us with the fact that we've
596 * transmitted or received whatever byte we last sent */
597
Huisung Kang19820512011-06-23 21:37:33 +0900598 i2c_s3c_irq_nextbyte(i2c, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599
600 out:
601 return IRQ_HANDLED;
602}
603
Simon Glass069a9502014-02-07 14:24:09 +0530604/*
605 * Disable the bus so that we won't get any interrupts from now on, or try
606 * to drive any lines. This is the default state when we don't have
607 * anything to send/receive.
608 *
609 * If there is an event on the bus, or we have a pre-existing event at
610 * kernel boot time, we may not notice the event and the I2C controller
611 * will lock the bus with the I2C clock line low indefinitely.
612 */
613static inline void s3c24xx_i2c_disable_bus(struct s3c24xx_i2c *i2c)
614{
615 unsigned long tmp;
616
617 /* Stop driving the I2C pins */
618 tmp = readl(i2c->regs + S3C2410_IICSTAT);
619 tmp &= ~S3C2410_IICSTAT_TXRXEN;
620 writel(tmp, i2c->regs + S3C2410_IICSTAT);
621
622 /* We don't expect any interrupts now, and don't want send acks */
623 tmp = readl(i2c->regs + S3C2410_IICCON);
624 tmp &= ~(S3C2410_IICCON_IRQEN | S3C2410_IICCON_IRQPEND |
625 S3C2410_IICCON_ACKEN);
626 writel(tmp, i2c->regs + S3C2410_IICCON);
627}
628
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629
630/* s3c24xx_i2c_set_master
631 *
632 * get the i2c bus for a master transaction
633*/
634
635static int s3c24xx_i2c_set_master(struct s3c24xx_i2c *i2c)
636{
637 unsigned long iicstat;
638 int timeout = 400;
639
640 while (timeout-- > 0) {
641 iicstat = readl(i2c->regs + S3C2410_IICSTAT);
Ben Dooks3d0911b2008-10-31 16:10:24 +0000642
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 if (!(iicstat & S3C2410_IICSTAT_BUSBUSY))
644 return 0;
645
646 msleep(1);
647 }
648
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 return -ETIMEDOUT;
650}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651
Daniel Kurtzfe724bf2012-11-15 17:43:32 +0530652/* s3c24xx_i2c_wait_idle
653 *
654 * wait for the i2c bus to become idle.
655*/
656
657static void s3c24xx_i2c_wait_idle(struct s3c24xx_i2c *i2c)
658{
659 unsigned long iicstat;
660 ktime_t start, now;
661 unsigned long delay;
Mark Brown31f313d2012-11-21 13:12:11 +0900662 int spins;
Daniel Kurtzfe724bf2012-11-15 17:43:32 +0530663
664 /* ensure the stop has been through the bus */
665
666 dev_dbg(i2c->dev, "waiting for bus idle\n");
667
668 start = now = ktime_get();
669
670 /*
671 * Most of the time, the bus is already idle within a few usec of the
672 * end of a transaction. However, really slow i2c devices can stretch
673 * the clock, delaying STOP generation.
674 *
Mark Brown31f313d2012-11-21 13:12:11 +0900675 * On slower SoCs this typically happens within a very small number of
676 * instructions so busy wait briefly to avoid scheduling overhead.
Daniel Kurtzfe724bf2012-11-15 17:43:32 +0530677 */
Mark Brown31f313d2012-11-21 13:12:11 +0900678 spins = 3;
Daniel Kurtzfe724bf2012-11-15 17:43:32 +0530679 iicstat = readl(i2c->regs + S3C2410_IICSTAT);
Mark Brown31f313d2012-11-21 13:12:11 +0900680 while ((iicstat & S3C2410_IICSTAT_START) && --spins) {
681 cpu_relax();
682 iicstat = readl(i2c->regs + S3C2410_IICSTAT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 }
684
Mark Brown31f313d2012-11-21 13:12:11 +0900685 /*
686 * If we do get an appreciable delay as a compromise between idle
687 * detection latency for the normal, fast case, and system load in the
688 * slow device case, use an exponential back off in the polling loop,
689 * up to 1/10th of the total timeout, then continue to poll at a
690 * constant rate up to the timeout.
691 */
Daniel Kurtzfe724bf2012-11-15 17:43:32 +0530692 delay = 1;
693 while ((iicstat & S3C2410_IICSTAT_START) &&
694 ktime_us_delta(now, start) < S3C2410_IDLE_TIMEOUT) {
695 usleep_range(delay, 2 * delay);
696 if (delay < S3C2410_IDLE_TIMEOUT / 10)
697 delay <<= 1;
698 now = ktime_get();
699 iicstat = readl(i2c->regs + S3C2410_IICSTAT);
700 }
701
702 if (iicstat & S3C2410_IICSTAT_START)
703 dev_warn(i2c->dev, "timeout waiting for bus idle\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704}
705
706/* s3c24xx_i2c_doxfer
707 *
708 * this starts an i2c transfer
709*/
710
Ben Dooks3d0911b2008-10-31 16:10:24 +0000711static int s3c24xx_i2c_doxfer(struct s3c24xx_i2c *i2c,
712 struct i2c_msg *msgs, int num)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713{
Daniel Kurtzfe724bf2012-11-15 17:43:32 +0530714 unsigned long timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 int ret;
716
Ben Dooksbe44f012008-10-31 16:10:22 +0000717 if (i2c->suspended)
Ben Dooks61c7cff2008-07-28 12:04:07 +0100718 return -EIO;
719
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 ret = s3c24xx_i2c_set_master(i2c);
721 if (ret != 0) {
722 dev_err(i2c->dev, "cannot get bus (error %d)\n", ret);
723 ret = -EAGAIN;
724 goto out;
725 }
726
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 i2c->msg = msgs;
728 i2c->msg_num = num;
729 i2c->msg_ptr = 0;
730 i2c->msg_idx = 0;
731 i2c->state = STATE_START;
732
733 s3c24xx_i2c_enable_irq(i2c);
734 s3c24xx_i2c_message_start(i2c, msgs);
Ben Dooks3d0911b2008-10-31 16:10:24 +0000735
Vasanth Ananthan117053f2013-11-11 16:50:20 +0530736 if (i2c->quirks & QUIRK_POLL) {
737 ret = i2c->msg_idx;
738
739 if (ret != num)
740 dev_dbg(i2c->dev, "incomplete xfer (%d)\n", ret);
741
742 goto out;
743 }
744
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 timeout = wait_event_timeout(i2c->wait, i2c->msg_num == 0, HZ * 5);
746
747 ret = i2c->msg_idx;
748
Ben Dooks3d0911b2008-10-31 16:10:24 +0000749 /* having these next two as dev_err() makes life very
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 * noisy when doing an i2cdetect */
751
752 if (timeout == 0)
753 dev_dbg(i2c->dev, "timeout\n");
754 else if (ret != num)
755 dev_dbg(i2c->dev, "incomplete xfer (%d)\n", ret);
756
Daniel Kurtz0da2e772012-11-15 17:43:31 +0530757 /* For QUIRK_HDMIPHY, bus is already disabled */
758 if (i2c->quirks & QUIRK_HDMIPHY)
759 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760
Daniel Kurtzfe724bf2012-11-15 17:43:32 +0530761 s3c24xx_i2c_wait_idle(i2c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762
Simon Glass069a9502014-02-07 14:24:09 +0530763 s3c24xx_i2c_disable_bus(i2c);
764
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 out:
Simon Glass069a9502014-02-07 14:24:09 +0530766 i2c->state = STATE_IDLE;
767
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 return ret;
769}
770
771/* s3c24xx_i2c_xfer
772 *
773 * first port of call from the i2c bus code when an message needs
Steven Cole44bbe872005-05-03 18:21:25 -0600774 * transferring across the i2c bus.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775*/
776
777static int s3c24xx_i2c_xfer(struct i2c_adapter *adap,
778 struct i2c_msg *msgs, int num)
779{
780 struct s3c24xx_i2c *i2c = (struct s3c24xx_i2c *)adap->algo_data;
781 int retry;
782 int ret;
783
Mark Brownc62c3ca2012-01-21 13:28:47 +0000784 pm_runtime_get_sync(&adap->dev);
Thomas Abrahamd3b64c52012-10-03 08:26:39 +0900785 clk_prepare_enable(i2c->clk);
Arnaud Patard (Rtp)d2360b82010-07-15 15:06:14 +0200786
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 for (retry = 0; retry < adap->retries; retry++) {
788
789 ret = s3c24xx_i2c_doxfer(i2c, msgs, num);
790
Arnaud Patard (Rtp)d2360b82010-07-15 15:06:14 +0200791 if (ret != -EAGAIN) {
Thomas Abrahamd3b64c52012-10-03 08:26:39 +0900792 clk_disable_unprepare(i2c->clk);
Mark Browna86ae9f2012-06-28 14:08:26 +0100793 pm_runtime_put(&adap->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 return ret;
Arnaud Patard (Rtp)d2360b82010-07-15 15:06:14 +0200795 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796
797 dev_dbg(i2c->dev, "Retrying transmission (%d)\n", retry);
798
799 udelay(100);
800 }
801
Thomas Abrahamd3b64c52012-10-03 08:26:39 +0900802 clk_disable_unprepare(i2c->clk);
Mark Browna86ae9f2012-06-28 14:08:26 +0100803 pm_runtime_put(&adap->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 return -EREMOTEIO;
805}
806
807/* declare our i2c functionality */
808static u32 s3c24xx_i2c_func(struct i2c_adapter *adap)
809{
Mark Brown14674e72012-05-30 10:55:34 +0200810 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | I2C_FUNC_NOSTART |
811 I2C_FUNC_PROTOCOL_MANGLING;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812}
813
814/* i2c bus registration info */
815
Jean Delvare8f9082c2006-09-03 22:39:46 +0200816static const struct i2c_algorithm s3c24xx_i2c_algorithm = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 .master_xfer = s3c24xx_i2c_xfer,
818 .functionality = s3c24xx_i2c_func,
819};
820
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821/* s3c24xx_i2c_calcdivisor
822 *
823 * return the divisor settings for a given frequency
824*/
825
826static int s3c24xx_i2c_calcdivisor(unsigned long clkin, unsigned int wanted,
827 unsigned int *div1, unsigned int *divs)
828{
829 unsigned int calc_divs = clkin / wanted;
830 unsigned int calc_div1;
831
832 if (calc_divs > (16*16))
833 calc_div1 = 512;
834 else
835 calc_div1 = 16;
836
837 calc_divs += calc_div1-1;
838 calc_divs /= calc_div1;
839
840 if (calc_divs == 0)
841 calc_divs = 1;
842 if (calc_divs > 17)
843 calc_divs = 17;
844
845 *divs = calc_divs;
846 *div1 = calc_div1;
847
848 return clkin / (calc_divs * calc_div1);
849}
850
Ben Dooks61c7cff2008-07-28 12:04:07 +0100851/* s3c24xx_i2c_clockrate
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 *
853 * work out a divisor for the user requested frequency setting,
854 * either by the requested frequency, or scanning the acceptable
855 * range of frequencies until something is found
856*/
857
Ben Dooks61c7cff2008-07-28 12:04:07 +0100858static int s3c24xx_i2c_clockrate(struct s3c24xx_i2c *i2c, unsigned int *got)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859{
Thomas Abraham4fd81eb2011-09-13 09:46:04 +0530860 struct s3c2410_platform_i2c *pdata = i2c->pdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 unsigned long clkin = clk_get_rate(i2c->clk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 unsigned int divs, div1;
Daniel Silverstonec564e6a2009-03-13 13:53:46 +0000863 unsigned long target_frequency;
Ben Dooks61c7cff2008-07-28 12:04:07 +0100864 u32 iiccon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 int freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866
Ben Dooks61c7cff2008-07-28 12:04:07 +0100867 i2c->clkrate = clkin;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 clkin /= 1000; /* clkin now in KHz */
Ben Dooks3d0911b2008-10-31 16:10:24 +0000869
Daniel Silverstonec564e6a2009-03-13 13:53:46 +0000870 dev_dbg(i2c->dev, "pdata desired frequency %lu\n", pdata->frequency);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
Daniel Silverstonec564e6a2009-03-13 13:53:46 +0000872 target_frequency = pdata->frequency ? pdata->frequency : 100000;
873
874 target_frequency /= 1000; /* Target frequency now in KHz */
875
876 freq = s3c24xx_i2c_calcdivisor(clkin, target_frequency, &div1, &divs);
877
878 if (freq > target_frequency) {
879 dev_err(i2c->dev,
880 "Unable to achieve desired frequency %luKHz." \
881 " Lowest achievable %dKHz\n", target_frequency, freq);
882 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 }
884
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 *got = freq;
Ben Dooks61c7cff2008-07-28 12:04:07 +0100886
887 iiccon = readl(i2c->regs + S3C2410_IICCON);
888 iiccon &= ~(S3C2410_IICCON_SCALEMASK | S3C2410_IICCON_TXDIV_512);
889 iiccon |= (divs-1);
890
891 if (div1 == 512)
892 iiccon |= S3C2410_IICCON_TXDIV_512;
893
Vasanth Ananthan117053f2013-11-11 16:50:20 +0530894 if (i2c->quirks & QUIRK_POLL)
895 iiccon |= S3C2410_IICCON_SCALE(2);
896
Ben Dooks61c7cff2008-07-28 12:04:07 +0100897 writel(iiccon, i2c->regs + S3C2410_IICCON);
898
Karol Lewandowski27452492012-04-23 18:24:00 +0200899 if (i2c->quirks & QUIRK_S3C2440) {
Ben Dooksa192f712009-03-27 10:52:13 +0000900 unsigned long sda_delay;
901
902 if (pdata->sda_delay) {
MyungJoo Ham70313072010-09-30 15:54:46 +0200903 sda_delay = clkin * pdata->sda_delay;
904 sda_delay = DIV_ROUND_UP(sda_delay, 1000000);
Ben Dooksa192f712009-03-27 10:52:13 +0000905 sda_delay = DIV_ROUND_UP(sda_delay, 5);
906 if (sda_delay > 3)
907 sda_delay = 3;
908 sda_delay |= S3C2410_IICLC_FILTER_ON;
909 } else
910 sda_delay = 0;
911
912 dev_dbg(i2c->dev, "IICLC=%08lx\n", sda_delay);
913 writel(sda_delay, i2c->regs + S3C2440_IICLC);
914 }
915
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 return 0;
917}
918
Naveen Krishna Ch61f4d6b2013-11-26 09:52:46 +0530919#if defined(CONFIG_ARM_S3C24XX_CPUFREQ)
Ben Dooks61c7cff2008-07-28 12:04:07 +0100920
921#define freq_to_i2c(_n) container_of(_n, struct s3c24xx_i2c, freq_transition)
922
923static int s3c24xx_i2c_cpufreq_transition(struct notifier_block *nb,
924 unsigned long val, void *data)
925{
926 struct s3c24xx_i2c *i2c = freq_to_i2c(nb);
Ben Dooks61c7cff2008-07-28 12:04:07 +0100927 unsigned int got;
928 int delta_f;
929 int ret;
930
931 delta_f = clk_get_rate(i2c->clk) - i2c->clkrate;
932
933 /* if we're post-change and the input clock has slowed down
934 * or at pre-change and the clock is about to speed up, then
935 * adjust our clock rate. <0 is slow, >0 speedup.
936 */
937
938 if ((val == CPUFREQ_POSTCHANGE && delta_f < 0) ||
939 (val == CPUFREQ_PRECHANGE && delta_f > 0)) {
Daniel Kurtz9bcd04b2012-11-15 17:43:30 +0530940 i2c_lock_adapter(&i2c->adap);
Ben Dooks61c7cff2008-07-28 12:04:07 +0100941 ret = s3c24xx_i2c_clockrate(i2c, &got);
Daniel Kurtz9bcd04b2012-11-15 17:43:30 +0530942 i2c_unlock_adapter(&i2c->adap);
Ben Dooks61c7cff2008-07-28 12:04:07 +0100943
944 if (ret < 0)
945 dev_err(i2c->dev, "cannot find frequency\n");
946 else
947 dev_info(i2c->dev, "setting freq %d\n", got);
948 }
949
950 return 0;
951}
952
953static inline int s3c24xx_i2c_register_cpufreq(struct s3c24xx_i2c *i2c)
954{
955 i2c->freq_transition.notifier_call = s3c24xx_i2c_cpufreq_transition;
956
957 return cpufreq_register_notifier(&i2c->freq_transition,
958 CPUFREQ_TRANSITION_NOTIFIER);
959}
960
961static inline void s3c24xx_i2c_deregister_cpufreq(struct s3c24xx_i2c *i2c)
962{
963 cpufreq_unregister_notifier(&i2c->freq_transition,
964 CPUFREQ_TRANSITION_NOTIFIER);
965}
966
967#else
968static inline int s3c24xx_i2c_register_cpufreq(struct s3c24xx_i2c *i2c)
969{
970 return 0;
971}
972
973static inline void s3c24xx_i2c_deregister_cpufreq(struct s3c24xx_i2c *i2c)
974{
975}
976#endif
977
Thomas Abraham5a5f5082011-09-13 09:46:05 +0530978#ifdef CONFIG_OF
979static int s3c24xx_i2c_parse_dt_gpio(struct s3c24xx_i2c *i2c)
980{
981 int idx, gpio, ret;
982
Karol Lewandowskiec39ef82012-04-23 18:24:01 +0200983 if (i2c->quirks & QUIRK_NO_GPIO)
984 return 0;
985
Thomas Abraham5a5f5082011-09-13 09:46:05 +0530986 for (idx = 0; idx < 2; idx++) {
987 gpio = of_get_gpio(i2c->dev->of_node, idx);
988 if (!gpio_is_valid(gpio)) {
989 dev_err(i2c->dev, "invalid gpio[%d]: %d\n", idx, gpio);
990 goto free_gpio;
991 }
Abhilash Kesavan963f2072012-11-19 15:48:46 +0530992 i2c->gpios[idx] = gpio;
Thomas Abraham5a5f5082011-09-13 09:46:05 +0530993
994 ret = gpio_request(gpio, "i2c-bus");
995 if (ret) {
996 dev_err(i2c->dev, "gpio [%d] request failed\n", gpio);
997 goto free_gpio;
998 }
999 }
1000 return 0;
1001
1002free_gpio:
1003 while (--idx >= 0)
1004 gpio_free(i2c->gpios[idx]);
1005 return -EINVAL;
1006}
1007
1008static void s3c24xx_i2c_dt_gpio_free(struct s3c24xx_i2c *i2c)
1009{
1010 unsigned int idx;
Karol Lewandowskiec39ef82012-04-23 18:24:01 +02001011
1012 if (i2c->quirks & QUIRK_NO_GPIO)
1013 return;
1014
Thomas Abraham5a5f5082011-09-13 09:46:05 +05301015 for (idx = 0; idx < 2; idx++)
1016 gpio_free(i2c->gpios[idx]);
1017}
1018#else
1019static int s3c24xx_i2c_parse_dt_gpio(struct s3c24xx_i2c *i2c)
1020{
Tushar Behera8ebe6612011-12-09 15:33:55 +05301021 return 0;
Thomas Abraham5a5f5082011-09-13 09:46:05 +05301022}
1023
1024static void s3c24xx_i2c_dt_gpio_free(struct s3c24xx_i2c *i2c)
1025{
1026}
1027#endif
1028
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029/* s3c24xx_i2c_init
1030 *
Ben Dooks3d0911b2008-10-31 16:10:24 +00001031 * initialise the controller, set the IO lines and frequency
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032*/
1033
1034static int s3c24xx_i2c_init(struct s3c24xx_i2c *i2c)
1035{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 struct s3c2410_platform_i2c *pdata;
1037 unsigned int freq;
1038
1039 /* get the plafrom data */
1040
Thomas Abraham4fd81eb2011-09-13 09:46:04 +05301041 pdata = i2c->pdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 /* write slave address */
Ben Dooks3d0911b2008-10-31 16:10:24 +00001044
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 writeb(pdata->slave_addr, i2c->regs + S3C2410_IICADD);
1046
1047 dev_info(i2c->dev, "slave address 0x%02x\n", pdata->slave_addr);
1048
Simon Glass069a9502014-02-07 14:24:09 +05301049 writel(0, i2c->regs + S3C2410_IICCON);
1050 writel(0, i2c->regs + S3C2410_IICSTAT);
Ben Dooks61c7cff2008-07-28 12:04:07 +01001051
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 /* we need to work out the divisors for the clock... */
1053
Ben Dooks61c7cff2008-07-28 12:04:07 +01001054 if (s3c24xx_i2c_clockrate(i2c, &freq) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 dev_err(i2c->dev, "cannot meet bus frequency required\n");
1056 return -EINVAL;
1057 }
1058
1059 /* todo - check that the i2c lines aren't being dragged anywhere */
1060
1061 dev_info(i2c->dev, "bus frequency set to %d KHz\n", freq);
Simon Glass069a9502014-02-07 14:24:09 +05301062 dev_dbg(i2c->dev, "S3C2410_IICCON=0x%02x\n",
1063 readl(i2c->regs + S3C2410_IICCON));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 return 0;
1066}
1067
Thomas Abraham5a5f5082011-09-13 09:46:05 +05301068#ifdef CONFIG_OF
1069/* s3c24xx_i2c_parse_dt
1070 *
1071 * Parse the device tree node and retreive the platform data.
1072*/
1073
1074static void
1075s3c24xx_i2c_parse_dt(struct device_node *np, struct s3c24xx_i2c *i2c)
1076{
1077 struct s3c2410_platform_i2c *pdata = i2c->pdata;
1078
1079 if (!np)
1080 return;
1081
1082 pdata->bus_num = -1; /* i2c bus number is dynamically assigned */
1083 of_property_read_u32(np, "samsung,i2c-sda-delay", &pdata->sda_delay);
1084 of_property_read_u32(np, "samsung,i2c-slave-addr", &pdata->slave_addr);
1085 of_property_read_u32(np, "samsung,i2c-max-bus-freq",
1086 (u32 *)&pdata->frequency);
1087}
1088#else
1089static void
1090s3c24xx_i2c_parse_dt(struct device_node *np, struct s3c24xx_i2c *i2c)
1091{
1092 return;
1093}
1094#endif
1095
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096/* s3c24xx_i2c_probe
1097 *
1098 * called by the bus driver when a suitable device is found
1099*/
1100
Russell King3ae5eae2005-11-09 22:32:44 +00001101static int s3c24xx_i2c_probe(struct platform_device *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102{
Ben Dooks692acbd2008-10-31 16:10:28 +00001103 struct s3c24xx_i2c *i2c;
Thomas Abraham4fd81eb2011-09-13 09:46:04 +05301104 struct s3c2410_platform_i2c *pdata = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 struct resource *res;
1106 int ret;
1107
Thomas Abraham5a5f5082011-09-13 09:46:05 +05301108 if (!pdev->dev.of_node) {
Jingoo Han6d4028c2013-07-30 16:59:33 +09001109 pdata = dev_get_platdata(&pdev->dev);
Thomas Abraham5a5f5082011-09-13 09:46:05 +05301110 if (!pdata) {
1111 dev_err(&pdev->dev, "no platform data\n");
1112 return -EINVAL;
1113 }
Ben Dooks6a039ca2008-10-31 16:10:27 +00001114 }
Ben Dooks399dee22008-07-28 12:04:06 +01001115
Mark Brown4ea15572012-01-21 13:28:46 +00001116 i2c = devm_kzalloc(&pdev->dev, sizeof(struct s3c24xx_i2c), GFP_KERNEL);
Jingoo Han46797a22014-05-13 10:51:58 +09001117 if (!i2c)
Ben Dooks692acbd2008-10-31 16:10:28 +00001118 return -ENOMEM;
Ben Dooks692acbd2008-10-31 16:10:28 +00001119
Thomas Abraham4fd81eb2011-09-13 09:46:04 +05301120 i2c->pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
Jingoo Han46797a22014-05-13 10:51:58 +09001121 if (!i2c->pdata)
Tushar Behera669da302013-01-24 15:41:06 +05301122 return -ENOMEM;
Thomas Abraham4fd81eb2011-09-13 09:46:04 +05301123
Karol Lewandowski27452492012-04-23 18:24:00 +02001124 i2c->quirks = s3c24xx_get_device_quirks(pdev);
Thomas Abraham4fd81eb2011-09-13 09:46:04 +05301125 if (pdata)
1126 memcpy(i2c->pdata, pdata, sizeof(*pdata));
Thomas Abraham5a5f5082011-09-13 09:46:05 +05301127 else
1128 s3c24xx_i2c_parse_dt(pdev->dev.of_node, i2c);
Thomas Abraham4fd81eb2011-09-13 09:46:04 +05301129
Ben Dooks692acbd2008-10-31 16:10:28 +00001130 strlcpy(i2c->adap.name, "s3c2410-i2c", sizeof(i2c->adap.name));
1131 i2c->adap.owner = THIS_MODULE;
1132 i2c->adap.algo = &s3c24xx_i2c_algorithm;
1133 i2c->adap.retries = 2;
Wolfram Sang53040322014-02-10 11:04:07 +01001134 i2c->adap.class = I2C_CLASS_HWMON | I2C_CLASS_SPD | I2C_CLASS_DEPRECATED;
Ben Dooks692acbd2008-10-31 16:10:28 +00001135 i2c->tx_setup = 50;
1136
Ben Dooks692acbd2008-10-31 16:10:28 +00001137 init_waitqueue_head(&i2c->wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138
1139 /* find the clock and enable it */
1140
Russell King3ae5eae2005-11-09 22:32:44 +00001141 i2c->dev = &pdev->dev;
Tushar Behera2b255b92013-01-24 15:41:07 +05301142 i2c->clk = devm_clk_get(&pdev->dev, "i2c");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 if (IS_ERR(i2c->clk)) {
Russell King3ae5eae2005-11-09 22:32:44 +00001144 dev_err(&pdev->dev, "cannot get clock\n");
Tushar Behera669da302013-01-24 15:41:06 +05301145 return -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 }
1147
Russell King3ae5eae2005-11-09 22:32:44 +00001148 dev_dbg(&pdev->dev, "clock source %p\n", i2c->clk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150
1151 /* map the registers */
1152
1153 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
Thierry Reding84dbf802013-01-21 11:09:03 +01001154 i2c->regs = devm_ioremap_resource(&pdev->dev, res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155
Linus Torvalds52caa592013-02-26 09:41:53 -08001156 if (IS_ERR(i2c->regs))
1157 return PTR_ERR(i2c->regs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158
Mark Browna72ad452012-11-05 09:33:39 +01001159 dev_dbg(&pdev->dev, "registers %p (%p)\n",
1160 i2c->regs, res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161
1162 /* setup info block for the i2c core */
1163
1164 i2c->adap.algo_data = i2c;
Russell King3ae5eae2005-11-09 22:32:44 +00001165 i2c->adap.dev.parent = &pdev->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166
Tomasz Figa2693ac62012-11-13 11:33:40 +01001167 i2c->pctrl = devm_pinctrl_get_select_default(i2c->dev);
1168
Abhilash Kesavan658122f2012-11-19 15:47:17 +05301169 /* inititalise the i2c gpio lines */
1170
1171 if (i2c->pdata->cfg_gpio) {
1172 i2c->pdata->cfg_gpio(to_platform_device(i2c->dev));
1173 } else if (IS_ERR(i2c->pctrl) && s3c24xx_i2c_parse_dt_gpio(i2c)) {
Tushar Beherad16933b2013-01-24 15:41:08 +05301174 return -EINVAL;
Abhilash Kesavan658122f2012-11-19 15:47:17 +05301175 }
1176
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 /* initialise the i2c controller */
1178
Tushar Beherad16933b2013-01-24 15:41:08 +05301179 clk_prepare_enable(i2c->clk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180 ret = s3c24xx_i2c_init(i2c);
Tushar Beherad16933b2013-01-24 15:41:08 +05301181 clk_disable_unprepare(i2c->clk);
1182 if (ret != 0) {
1183 dev_err(&pdev->dev, "I2C controller init failed\n");
1184 return ret;
1185 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 /* find the IRQ for this unit (note, this relies on the init call to
Ben Dooks3d0911b2008-10-31 16:10:24 +00001187 * ensure no current IRQs pending
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 */
1189
Vasanth Ananthan117053f2013-11-11 16:50:20 +05301190 if (!(i2c->quirks & QUIRK_POLL)) {
1191 i2c->irq = ret = platform_get_irq(pdev, 0);
1192 if (ret <= 0) {
1193 dev_err(&pdev->dev, "cannot find IRQ\n");
1194 return ret;
1195 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196
Tushar Behera2b255b92013-01-24 15:41:07 +05301197 ret = devm_request_irq(&pdev->dev, i2c->irq, s3c24xx_i2c_irq, 0,
Vasanth Ananthan117053f2013-11-11 16:50:20 +05301198 dev_name(&pdev->dev), i2c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199
Vasanth Ananthan117053f2013-11-11 16:50:20 +05301200 if (ret != 0) {
1201 dev_err(&pdev->dev, "cannot claim IRQ %d\n", i2c->irq);
1202 return ret;
1203 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204 }
1205
Ben Dooks61c7cff2008-07-28 12:04:07 +01001206 ret = s3c24xx_i2c_register_cpufreq(i2c);
1207 if (ret < 0) {
1208 dev_err(&pdev->dev, "failed to register cpufreq notifier\n");
Tushar Beherad16933b2013-01-24 15:41:08 +05301209 return ret;
Ben Dooks61c7cff2008-07-28 12:04:07 +01001210 }
1211
Ben Dooks399dee22008-07-28 12:04:06 +01001212 /* Note, previous versions of the driver used i2c_add_adapter()
1213 * to add the bus at any number. We now pass the bus number via
1214 * the platform data, so if unset it will now default to always
1215 * being bus 0.
1216 */
1217
Thomas Abraham4fd81eb2011-09-13 09:46:04 +05301218 i2c->adap.nr = i2c->pdata->bus_num;
Thomas Abraham5a5f5082011-09-13 09:46:05 +05301219 i2c->adap.dev.of_node = pdev->dev.of_node;
Ben Dooks399dee22008-07-28 12:04:06 +01001220
1221 ret = i2c_add_numbered_adapter(&i2c->adap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 if (ret < 0) {
Russell King3ae5eae2005-11-09 22:32:44 +00001223 dev_err(&pdev->dev, "failed to add bus to i2c core\n");
Tushar Beheradc6fea42013-01-24 15:41:09 +05301224 s3c24xx_i2c_deregister_cpufreq(i2c);
1225 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226 }
1227
Russell King3ae5eae2005-11-09 22:32:44 +00001228 platform_set_drvdata(pdev, i2c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229
Mark Brownc62c3ca2012-01-21 13:28:47 +00001230 pm_runtime_enable(&pdev->dev);
1231 pm_runtime_enable(&i2c->adap.dev);
1232
Jean Delvare22e965c2009-01-07 14:29:16 +01001233 dev_info(&pdev->dev, "%s: S3C I2C adapter\n", dev_name(&i2c->adap.dev));
Ben Dooks5b687902007-05-01 23:26:35 +02001234 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235}
1236
1237/* s3c24xx_i2c_remove
1238 *
1239 * called when device is removed from the bus
1240*/
1241
Russell King3ae5eae2005-11-09 22:32:44 +00001242static int s3c24xx_i2c_remove(struct platform_device *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243{
Russell King3ae5eae2005-11-09 22:32:44 +00001244 struct s3c24xx_i2c *i2c = platform_get_drvdata(pdev);
Ben Dooks5b687902007-05-01 23:26:35 +02001245
Mark Brownc62c3ca2012-01-21 13:28:47 +00001246 pm_runtime_disable(&i2c->adap.dev);
1247 pm_runtime_disable(&pdev->dev);
1248
Ben Dooks61c7cff2008-07-28 12:04:07 +01001249 s3c24xx_i2c_deregister_cpufreq(i2c);
1250
Ben Dooks5b687902007-05-01 23:26:35 +02001251 i2c_del_adapter(&i2c->adap);
Ben Dooks5b687902007-05-01 23:26:35 +02001252
Tomasz Figa2693ac62012-11-13 11:33:40 +01001253 if (pdev->dev.of_node && IS_ERR(i2c->pctrl))
1254 s3c24xx_i2c_dt_gpio_free(i2c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255
1256 return 0;
1257}
1258
Mark Brown2935e0e2012-11-05 09:33:38 +01001259#ifdef CONFIG_PM_SLEEP
Magnus Damm6a6c61892009-07-08 13:22:47 +02001260static int s3c24xx_i2c_suspend_noirq(struct device *dev)
Ben Dooksbe44f012008-10-31 16:10:22 +00001261{
Magnus Damm6a6c61892009-07-08 13:22:47 +02001262 struct platform_device *pdev = to_platform_device(dev);
1263 struct s3c24xx_i2c *i2c = platform_get_drvdata(pdev);
1264
Ben Dooksbe44f012008-10-31 16:10:22 +00001265 i2c->suspended = 1;
Magnus Damm6a6c61892009-07-08 13:22:47 +02001266
Ben Dooksbe44f012008-10-31 16:10:22 +00001267 return 0;
1268}
1269
Magnus Damm6a6c61892009-07-08 13:22:47 +02001270static int s3c24xx_i2c_resume(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271{
Magnus Damm6a6c61892009-07-08 13:22:47 +02001272 struct platform_device *pdev = to_platform_device(dev);
1273 struct s3c24xx_i2c *i2c = platform_get_drvdata(pdev);
Russell King9480e302005-10-28 09:52:56 -07001274
Thomas Abrahamd3b64c52012-10-03 08:26:39 +09001275 clk_prepare_enable(i2c->clk);
Ben Dooksbe44f012008-10-31 16:10:22 +00001276 s3c24xx_i2c_init(i2c);
Thomas Abrahamd3b64c52012-10-03 08:26:39 +09001277 clk_disable_unprepare(i2c->clk);
Olof Johanssonce78cc02014-04-11 15:19:41 -07001278 i2c->suspended = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279
1280 return 0;
1281}
Mark Brown2935e0e2012-11-05 09:33:38 +01001282#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283
Mark Brown2935e0e2012-11-05 09:33:38 +01001284#ifdef CONFIG_PM
Alexey Dobriyan47145212009-12-14 18:00:08 -08001285static const struct dev_pm_ops s3c24xx_i2c_dev_pm_ops = {
Mark Brown2935e0e2012-11-05 09:33:38 +01001286#ifdef CONFIG_PM_SLEEP
Magnus Damm6a6c61892009-07-08 13:22:47 +02001287 .suspend_noirq = s3c24xx_i2c_suspend_noirq,
1288 .resume = s3c24xx_i2c_resume,
Mark Brown2935e0e2012-11-05 09:33:38 +01001289#endif
Magnus Damm6a6c61892009-07-08 13:22:47 +02001290};
1291
1292#define S3C24XX_DEV_PM_OPS (&s3c24xx_i2c_dev_pm_ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293#else
Magnus Damm6a6c61892009-07-08 13:22:47 +02001294#define S3C24XX_DEV_PM_OPS NULL
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295#endif
1296
1297/* device driver for platform bus bits */
1298
Ben Dooks7d85ccd2009-06-12 10:45:29 +01001299static struct platform_driver s3c24xx_i2c_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300 .probe = s3c24xx_i2c_probe,
1301 .remove = s3c24xx_i2c_remove,
Ben Dooks7d85ccd2009-06-12 10:45:29 +01001302 .id_table = s3c24xx_driver_ids,
Russell King3ae5eae2005-11-09 22:32:44 +00001303 .driver = {
1304 .owner = THIS_MODULE,
Ben Dooks7d85ccd2009-06-12 10:45:29 +01001305 .name = "s3c-i2c",
Magnus Damm6a6c61892009-07-08 13:22:47 +02001306 .pm = S3C24XX_DEV_PM_OPS,
Karol Lewandowski9df7ead2012-03-21 20:11:51 +01001307 .of_match_table = of_match_ptr(s3c24xx_i2c_match),
Russell King3ae5eae2005-11-09 22:32:44 +00001308 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309};
1310
1311static int __init i2c_adap_s3c_init(void)
1312{
Ben Dooks7d85ccd2009-06-12 10:45:29 +01001313 return platform_driver_register(&s3c24xx_i2c_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314}
Mark Brown18dc83a2009-02-26 16:29:22 +00001315subsys_initcall(i2c_adap_s3c_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316
1317static void __exit i2c_adap_s3c_exit(void)
1318{
Ben Dooks7d85ccd2009-06-12 10:45:29 +01001319 platform_driver_unregister(&s3c24xx_i2c_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321module_exit(i2c_adap_s3c_exit);
1322
1323MODULE_DESCRIPTION("S3C24XX I2C Bus driver");
1324MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>");
1325MODULE_LICENSE("GPL");