i2c-s3c2410.c 31.1 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-or-later
Linus Torvalds's avatar
Linus Torvalds committed
2
3
/* linux/drivers/i2c/busses/i2c-s3c2410.c
 *
4
 * Copyright (C) 2004,2005,2009 Simtec Electronics
Linus Torvalds's avatar
Linus Torvalds committed
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 *	Ben Dooks <ben@simtec.co.uk>
 *
 * S3C2410 I2C Controller
*/

#include <linux/kernel.h>
#include <linux/module.h>

#include <linux/i2c.h>
#include <linux/init.h>
#include <linux/time.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/errno.h>
#include <linux/err.h>
20
#include <linux/platform_device.h>
21
#include <linux/pm_runtime.h>
22
#include <linux/clk.h>
23
#include <linux/cpufreq.h>
24
#include <linux/slab.h>
25
#include <linux/io.h>
Sachin Kamat's avatar
Sachin Kamat committed
26
#include <linux/of.h>
27
#include <linux/of_device.h>
28
#include <linux/gpio/consumer.h>
29
#include <linux/pinctrl/consumer.h>
30
31
#include <linux/mfd/syscon.h>
#include <linux/regmap.h>
Linus Torvalds's avatar
Linus Torvalds committed
32
33
34

#include <asm/irq.h>

35
#include <linux/platform_data/i2c-s3c2410.h>
Linus Torvalds's avatar
Linus Torvalds committed
36

37
38
/* see s3c2410x user guide, v1.1, section 9 (p447) for more info */

39
40
41
42
43
#define S3C2410_IICCON			0x00
#define S3C2410_IICSTAT			0x04
#define S3C2410_IICADD			0x08
#define S3C2410_IICDS			0x0C
#define S3C2440_IICLC			0x10
44

45
46
47
48
49
50
#define S3C2410_IICCON_ACKEN		(1 << 7)
#define S3C2410_IICCON_TXDIV_16		(0 << 6)
#define S3C2410_IICCON_TXDIV_512	(1 << 6)
#define S3C2410_IICCON_IRQEN		(1 << 5)
#define S3C2410_IICCON_IRQPEND		(1 << 4)
#define S3C2410_IICCON_SCALE(x)		((x) & 0xf)
51
52
#define S3C2410_IICCON_SCALEMASK	(0xf)

53
54
55
56
57
#define S3C2410_IICSTAT_MASTER_RX	(2 << 6)
#define S3C2410_IICSTAT_MASTER_TX	(3 << 6)
#define S3C2410_IICSTAT_SLAVE_RX	(0 << 6)
#define S3C2410_IICSTAT_SLAVE_TX	(1 << 6)
#define S3C2410_IICSTAT_MODEMASK	(3 << 6)
58

59
60
61
62
63
64
65
#define S3C2410_IICSTAT_START		(1 << 5)
#define S3C2410_IICSTAT_BUSBUSY		(1 << 5)
#define S3C2410_IICSTAT_TXRXEN		(1 << 4)
#define S3C2410_IICSTAT_ARBITR		(1 << 3)
#define S3C2410_IICSTAT_ASSLAVE		(1 << 2)
#define S3C2410_IICSTAT_ADDR0		(1 << 1)
#define S3C2410_IICSTAT_LASTBIT		(1 << 0)
66
67
68
69
70
71
72

#define S3C2410_IICLC_SDA_DELAY0	(0 << 0)
#define S3C2410_IICLC_SDA_DELAY5	(1 << 0)
#define S3C2410_IICLC_SDA_DELAY10	(2 << 0)
#define S3C2410_IICLC_SDA_DELAY15	(3 << 0)
#define S3C2410_IICLC_SDA_DELAY_MASK	(3 << 0)

73
#define S3C2410_IICLC_FILTER_ON		(1 << 2)
74

75
76
/* Treat S3C2410 as baseline hardware, anything else is supported via quirks */
#define QUIRK_S3C2440		(1 << 0)
77
78
#define QUIRK_HDMIPHY		(1 << 1)
#define QUIRK_NO_GPIO		(1 << 2)
79
#define QUIRK_POLL		(1 << 3)
Linus Torvalds's avatar
Linus Torvalds committed
80

81
82
83
/* Max time to wait for bus to become idle after a xfer (in us) */
#define S3C2410_IDLE_TIMEOUT	5000

84
85
86
/* Exynos5 Sysreg offset */
#define EXYNOS5_SYS_I2C_CFG	0x0234

87
/* i2c controller state */
Linus Torvalds's avatar
Linus Torvalds committed
88
89
90
91
92
93
94
95
96
97
enum s3c24xx_i2c_state {
	STATE_IDLE,
	STATE_START,
	STATE_READ,
	STATE_WRITE,
	STATE_STOP
};

struct s3c24xx_i2c {
	wait_queue_head_t	wait;
98
	kernel_ulong_t		quirks;
Linus Torvalds's avatar
Linus Torvalds committed
99
100
101
102
103
104

	struct i2c_msg		*msg;
	unsigned int		msg_num;
	unsigned int		msg_idx;
	unsigned int		msg_ptr;

105
	unsigned int		tx_setup;
106
	unsigned int		irq;
107

Linus Torvalds's avatar
Linus Torvalds committed
108
	enum s3c24xx_i2c_state	state;
109
	unsigned long		clkrate;
Linus Torvalds's avatar
Linus Torvalds committed
110
111
112
113
114

	void __iomem		*regs;
	struct clk		*clk;
	struct device		*dev;
	struct i2c_adapter	adap;
115

116
	struct s3c2410_platform_i2c	*pdata;
117
	struct gpio_desc	*gpios[2];
118
	struct pinctrl          *pctrl;
119
#if defined(CONFIG_ARM_S3C24XX_CPUFREQ)
120
121
	struct notifier_block	freq_transition;
#endif
122
123
	struct regmap		*sysreg;
	unsigned int		sys_i2c_cfg;
Linus Torvalds's avatar
Linus Torvalds committed
124
125
};

126
static const struct platform_device_id s3c24xx_driver_ids[] = {
127
128
129
130
131
132
	{
		.name		= "s3c2410-i2c",
		.driver_data	= 0,
	}, {
		.name		= "s3c2440-i2c",
		.driver_data	= QUIRK_S3C2440,
133
134
135
	}, {
		.name		= "s3c2440-hdmiphy-i2c",
		.driver_data	= QUIRK_S3C2440 | QUIRK_HDMIPHY | QUIRK_NO_GPIO,
136
137
138
139
	}, { },
};
MODULE_DEVICE_TABLE(platform, s3c24xx_driver_ids);

140
141
static int i2c_s3c_irq_nextbyte(struct s3c24xx_i2c *i2c, unsigned long iicstat);

142
143
144
145
#ifdef CONFIG_OF
static const struct of_device_id s3c24xx_i2c_match[] = {
	{ .compatible = "samsung,s3c2410-i2c", .data = (void *)0 },
	{ .compatible = "samsung,s3c2440-i2c", .data = (void *)QUIRK_S3C2440 },
146
147
	{ .compatible = "samsung,s3c2440-hdmiphy-i2c",
	  .data = (void *)(QUIRK_S3C2440 | QUIRK_HDMIPHY | QUIRK_NO_GPIO) },
148
149
	{ .compatible = "samsung,exynos5-sata-phy-i2c",
	  .data = (void *)(QUIRK_S3C2440 | QUIRK_POLL | QUIRK_NO_GPIO) },
150
151
152
153
	{},
};
MODULE_DEVICE_TABLE(of, s3c24xx_i2c_match);
#endif
Linus Torvalds's avatar
Linus Torvalds committed
154

155
/*
156
 * Get controller type either from device tree or platform device variant.
157
 */
158
static inline kernel_ulong_t s3c24xx_get_device_quirks(struct platform_device *pdev)
Linus Torvalds's avatar
Linus Torvalds committed
159
{
160
161
	if (pdev->dev.of_node)
		return (kernel_ulong_t)of_device_get_match_data(&pdev->dev);
162

163
	return platform_get_device_id(pdev)->driver_data;
Linus Torvalds's avatar
Linus Torvalds committed
164
165
}

166
167
/*
 * Complete the message and wake up the caller, using the given return code,
Linus Torvalds's avatar
Linus Torvalds committed
168
 * or zero to mean ok.
169
 */
Linus Torvalds's avatar
Linus Torvalds committed
170
171
172
173
174
175
static inline void s3c24xx_i2c_master_complete(struct s3c24xx_i2c *i2c, int ret)
{
	dev_dbg(i2c->dev, "master_complete %d\n", ret);

	i2c->msg_ptr = 0;
	i2c->msg = NULL;
176
	i2c->msg_idx++;
Linus Torvalds's avatar
Linus Torvalds committed
177
178
179
180
	i2c->msg_num = 0;
	if (ret)
		i2c->msg_idx = ret;

181
182
	if (!(i2c->quirks & QUIRK_POLL))
		wake_up(&i2c->wait);
Linus Torvalds's avatar
Linus Torvalds committed
183
184
185
186
187
}

static inline void s3c24xx_i2c_disable_ack(struct s3c24xx_i2c *i2c)
{
	unsigned long tmp;
188

Linus Torvalds's avatar
Linus Torvalds committed
189
190
191
192
193
194
195
	tmp = readl(i2c->regs + S3C2410_IICCON);
	writel(tmp & ~S3C2410_IICCON_ACKEN, i2c->regs + S3C2410_IICCON);
}

static inline void s3c24xx_i2c_enable_ack(struct s3c24xx_i2c *i2c)
{
	unsigned long tmp;
196

Linus Torvalds's avatar
Linus Torvalds committed
197
198
199
200
201
202
203
204
	tmp = readl(i2c->regs + S3C2410_IICCON);
	writel(tmp | S3C2410_IICCON_ACKEN, i2c->regs + S3C2410_IICCON);
}

/* irq enable/disable functions */
static inline void s3c24xx_i2c_disable_irq(struct s3c24xx_i2c *i2c)
{
	unsigned long tmp;
205

Linus Torvalds's avatar
Linus Torvalds committed
206
207
208
209
210
211
212
	tmp = readl(i2c->regs + S3C2410_IICCON);
	writel(tmp & ~S3C2410_IICCON_IRQEN, i2c->regs + S3C2410_IICCON);
}

static inline void s3c24xx_i2c_enable_irq(struct s3c24xx_i2c *i2c)
{
	unsigned long tmp;
213

Linus Torvalds's avatar
Linus Torvalds committed
214
215
216
217
	tmp = readl(i2c->regs + S3C2410_IICCON);
	writel(tmp | S3C2410_IICCON_IRQEN, i2c->regs + S3C2410_IICCON);
}

218
219
220
221
222
223
224
225
226
227
228
229
230
static bool is_ack(struct s3c24xx_i2c *i2c)
{
	int tries;

	for (tries = 50; tries; --tries) {
		if (readl(i2c->regs + S3C2410_IICCON)
			& S3C2410_IICCON_IRQPEND) {
			if (!(readl(i2c->regs + S3C2410_IICSTAT)
				& S3C2410_IICSTAT_LASTBIT))
				return true;
		}
		usleep_range(1000, 2000);
	}
Masanari Iida's avatar
Masanari Iida committed
231
	dev_err(i2c->dev, "ack was not received\n");
232
233
	return false;
}
Linus Torvalds's avatar
Linus Torvalds committed
234

235
/*
236
 * put the start of a message onto the bus
237
 */
238
static void s3c24xx_i2c_message_start(struct s3c24xx_i2c *i2c,
Linus Torvalds's avatar
Linus Torvalds committed
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
				      struct i2c_msg *msg)
{
	unsigned int addr = (msg->addr & 0x7f) << 1;
	unsigned long stat;
	unsigned long iiccon;

	stat = 0;
	stat |=  S3C2410_IICSTAT_TXRXEN;

	if (msg->flags & I2C_M_RD) {
		stat |= S3C2410_IICSTAT_MASTER_RX;
		addr |= 1;
	} else
		stat |= S3C2410_IICSTAT_MASTER_TX;

	if (msg->flags & I2C_M_REV_DIR_ADDR)
		addr ^= 1;

257
	/* todo - check for whether ack wanted or not */
Linus Torvalds's avatar
Linus Torvalds committed
258
259
260
261
	s3c24xx_i2c_enable_ack(i2c);

	iiccon = readl(i2c->regs + S3C2410_IICCON);
	writel(stat, i2c->regs + S3C2410_IICSTAT);
262

Linus Torvalds's avatar
Linus Torvalds committed
263
264
	dev_dbg(i2c->dev, "START: %08lx to IICSTAT, %02x to DS\n", stat, addr);
	writeb(addr, i2c->regs + S3C2410_IICDS);
265

266
267
268
269
	/*
	 * delay here to ensure the data byte has gotten onto the bus
	 * before the transaction is started
	 */
270
271
	ndelay(i2c->tx_setup);

Linus Torvalds's avatar
Linus Torvalds committed
272
273
	dev_dbg(i2c->dev, "iiccon, %08lx\n", iiccon);
	writel(iiccon, i2c->regs + S3C2410_IICCON);
274
275

	stat |= S3C2410_IICSTAT_START;
Linus Torvalds's avatar
Linus Torvalds committed
276
	writel(stat, i2c->regs + S3C2410_IICSTAT);
277
278
279
280
281
282
283
284
285
286

	if (i2c->quirks & QUIRK_POLL) {
		while ((i2c->msg_num != 0) && is_ack(i2c)) {
			i2c_s3c_irq_nextbyte(i2c, stat);
			stat = readl(i2c->regs + S3C2410_IICSTAT);

			if (stat & S3C2410_IICSTAT_ARBITR)
				dev_err(i2c->dev, "deal with arbitration loss\n");
		}
	}
Linus Torvalds's avatar
Linus Torvalds committed
287
288
289
290
291
292
293
294
}

static inline void s3c24xx_i2c_stop(struct s3c24xx_i2c *i2c, int ret)
{
	unsigned long iicstat = readl(i2c->regs + S3C2410_IICSTAT);

	dev_dbg(i2c->dev, "STOP\n");

295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
	/*
	 * The datasheet says that the STOP sequence should be:
	 *  1) I2CSTAT.5 = 0	- Clear BUSY (or 'generate STOP')
	 *  2) I2CCON.4 = 0	- Clear IRQPEND
	 *  3) Wait until the stop condition takes effect.
	 *  4*) I2CSTAT.4 = 0	- Clear TXRXEN
	 *
	 * Where, step "4*" is only for buses with the "HDMIPHY" quirk.
	 *
	 * However, after much experimentation, it appears that:
	 * a) normal buses automatically clear BUSY and transition from
	 *    Master->Slave when they complete generating a STOP condition.
	 *    Therefore, step (3) can be done in doxfer() by polling I2CCON.4
	 *    after starting the STOP generation here.
	 * b) HDMIPHY bus does neither, so there is no way to do step 3.
	 *    There is no indication when this bus has finished generating
	 *    STOP.
	 *
	 * In fact, we have found that as soon as the IRQPEND bit is cleared in
	 * step 2, the HDMIPHY bus generates the STOP condition, and then
	 * immediately starts transferring another data byte, even though the
	 * bus is supposedly stopped.  This is presumably because the bus is
	 * still in "Master" mode, and its BUSY bit is still set.
	 *
	 * To avoid these extra post-STOP transactions on HDMI phy devices, we
	 * just disable Serial Output on the bus (I2CSTAT.4 = 0) directly,
	 * instead of first generating a proper STOP condition.  This should
	 * float SDA & SCK terminating the transfer.  Subsequent transfers
	 *  start with a proper START condition, and proceed normally.
	 *
	 * The HDMIPHY bus is an internal bus that always has exactly two
	 * devices, the host as Master and the HDMIPHY device as the slave.
	 * Skipping the STOP condition has been tested on this bus and works.
	 */
	if (i2c->quirks & QUIRK_HDMIPHY) {
		/* Stop driving the I2C pins */
		iicstat &= ~S3C2410_IICSTAT_TXRXEN;
	} else {
		/* stop the transfer */
		iicstat &= ~S3C2410_IICSTAT_START;
	}
Linus Torvalds's avatar
Linus Torvalds committed
336
	writel(iicstat, i2c->regs + S3C2410_IICSTAT);
337

Linus Torvalds's avatar
Linus Torvalds committed
338
	i2c->state = STATE_STOP;
339

Linus Torvalds's avatar
Linus Torvalds committed
340
341
342
343
	s3c24xx_i2c_master_complete(i2c, ret);
	s3c24xx_i2c_disable_irq(i2c);
}

344
345
346
347
/*
 * helper functions to determine the current state in the set of
 * messages we are sending
 */
Linus Torvalds's avatar
Linus Torvalds committed
348

349
/*
350
 * returns TRUE if the current message is the last in the set
351
 */
Linus Torvalds's avatar
Linus Torvalds committed
352
353
354
355
356
static inline int is_lastmsg(struct s3c24xx_i2c *i2c)
{
	return i2c->msg_idx >= (i2c->msg_num - 1);
}

357
/*
Linus Torvalds's avatar
Linus Torvalds committed
358
 * returns TRUE if we this is the last byte in the current message
359
 */
Linus Torvalds's avatar
Linus Torvalds committed
360
361
static inline int is_msglast(struct s3c24xx_i2c *i2c)
{
362
363
	/*
	 * msg->len is always 1 for the first byte of smbus block read.
364
	 * Actual length will be read from slave. More bytes will be
365
366
	 * read according to the length then.
	 */
367
368
369
	if (i2c->msg->flags & I2C_M_RECV_LEN && i2c->msg->len == 1)
		return 0;

Linus Torvalds's avatar
Linus Torvalds committed
370
371
372
	return i2c->msg_ptr == i2c->msg->len-1;
}

373
/*
Linus Torvalds's avatar
Linus Torvalds committed
374
 * returns TRUE if we reached the end of the current message
375
 */
Linus Torvalds's avatar
Linus Torvalds committed
376
377
378
379
380
static inline int is_msgend(struct s3c24xx_i2c *i2c)
{
	return i2c->msg_ptr >= i2c->msg->len;
}

381
/*
Linus Torvalds's avatar
Linus Torvalds committed
382
383
 * process an interrupt and work out what to do
 */
384
static int i2c_s3c_irq_nextbyte(struct s3c24xx_i2c *i2c, unsigned long iicstat)
Linus Torvalds's avatar
Linus Torvalds committed
385
386
387
388
389
390
391
392
{
	unsigned long tmp;
	unsigned char byte;
	int ret = 0;

	switch (i2c->state) {

	case STATE_IDLE:
393
		dev_err(i2c->dev, "%s: called in STATE_IDLE\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
394
395
396
		goto out;

	case STATE_STOP:
397
		dev_err(i2c->dev, "%s: called in STATE_STOP\n", __func__);
398
		s3c24xx_i2c_disable_irq(i2c);
Linus Torvalds's avatar
Linus Torvalds committed
399
400
401
		goto out_ack;

	case STATE_START:
402
403
		/*
		 * last thing we did was send a start condition on the
Linus Torvalds's avatar
Linus Torvalds committed
404
405
		 * bus, or started a new i2c message
		 */
406
		if (iicstat & S3C2410_IICSTAT_LASTBIT &&
Linus Torvalds's avatar
Linus Torvalds committed
407
408
409
		    !(i2c->msg->flags & I2C_M_IGNORE_NAK)) {
			/* ack was not received... */
			dev_dbg(i2c->dev, "ack was not received\n");
410
			s3c24xx_i2c_stop(i2c, -ENXIO);
Linus Torvalds's avatar
Linus Torvalds committed
411
412
413
414
415
416
417
418
			goto out_ack;
		}

		if (i2c->msg->flags & I2C_M_RD)
			i2c->state = STATE_READ;
		else
			i2c->state = STATE_WRITE;

419
420
421
422
		/*
		 * Terminate the transfer if there is nothing to do
		 * as this is used by the i2c probe to find devices.
		 */
Linus Torvalds's avatar
Linus Torvalds committed
423
424
425
426
427
428
429
430
		if (is_lastmsg(i2c) && i2c->msg->len == 0) {
			s3c24xx_i2c_stop(i2c, 0);
			goto out_ack;
		}

		if (i2c->state == STATE_READ)
			goto prepare_read;

431
432
433
434
		/*
		 * fall through to the write state, as we will need to
		 * send a byte as well
		 */
435
		fallthrough;
Linus Torvalds's avatar
Linus Torvalds committed
436
	case STATE_WRITE:
437
438
		/*
		 * we are writing data to the device... check for the
Linus Torvalds's avatar
Linus Torvalds committed
439
440
		 * end of the message, and if so, work out what to do
		 */
441
442
443
444
445
446
447
448
449
		if (!(i2c->msg->flags & I2C_M_IGNORE_NAK)) {
			if (iicstat & S3C2410_IICSTAT_LASTBIT) {
				dev_dbg(i2c->dev, "WRITE: No Ack\n");

				s3c24xx_i2c_stop(i2c, -ECONNREFUSED);
				goto out_ack;
			}
		}

450
 retry_write:
451

Linus Torvalds's avatar
Linus Torvalds committed
452
453
454
		if (!is_msgend(i2c)) {
			byte = i2c->msg->buf[i2c->msg_ptr++];
			writeb(byte, i2c->regs + S3C2410_IICDS);
455

456
457
			/*
			 * delay after writing the byte to allow the
458
459
460
			 * data setup time on the bus, as writing the
			 * data to the register causes the first bit
			 * to appear on SDA, and SCL will change as
461
462
			 * soon as the interrupt is acknowledged
			 */
463
464
			ndelay(i2c->tx_setup);

Linus Torvalds's avatar
Linus Torvalds committed
465
466
467
468
469
470
		} else if (!is_lastmsg(i2c)) {
			/* we need to go to the next i2c message */

			dev_dbg(i2c->dev, "WRITE: Next Message\n");

			i2c->msg_ptr = 0;
471
			i2c->msg_idx++;
Linus Torvalds's avatar
Linus Torvalds committed
472
			i2c->msg++;
473

Linus Torvalds's avatar
Linus Torvalds committed
474
475
476
477
			/* check to see if we need to do another message */
			if (i2c->msg->flags & I2C_M_NOSTART) {

				if (i2c->msg->flags & I2C_M_RD) {
478
479
					/*
					 * cannot do this, the controller
Linus Torvalds's avatar
Linus Torvalds committed
480
					 * forces us to send a new START
481
482
					 * when we change direction
					 */
483
484
					dev_dbg(i2c->dev,
						"missing START before write->read\n");
Linus Torvalds's avatar
Linus Torvalds committed
485
					s3c24xx_i2c_stop(i2c, -EINVAL);
486
					break;
Linus Torvalds's avatar
Linus Torvalds committed
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
				}

				goto retry_write;
			} else {
				/* send the new start */
				s3c24xx_i2c_message_start(i2c, i2c->msg);
				i2c->state = STATE_START;
			}

		} else {
			/* send stop */
			s3c24xx_i2c_stop(i2c, 0);
		}
		break;

	case STATE_READ:
503
504
		/*
		 * we have a byte of data in the data register, do
505
		 * something with it, and then work out whether we are
Linus Torvalds's avatar
Linus Torvalds committed
506
507
508
509
510
		 * going to do any more read/write
		 */
		byte = readb(i2c->regs + S3C2410_IICDS);
		i2c->msg->buf[i2c->msg_ptr++] = byte;

511
512
513
		/* Add actual length to read for smbus block read */
		if (i2c->msg->flags & I2C_M_RECV_LEN && i2c->msg->len == 1)
			i2c->msg->len += byte;
514
 prepare_read:
Linus Torvalds's avatar
Linus Torvalds committed
515
516
517
518
519
		if (is_msglast(i2c)) {
			/* last byte of buffer */

			if (is_lastmsg(i2c))
				s3c24xx_i2c_disable_ack(i2c);
520

Linus Torvalds's avatar
Linus Torvalds committed
521
		} else if (is_msgend(i2c)) {
522
523
524
525
			/*
			 * ok, we've read the entire buffer, see if there
			 * is anything else we need to do
			 */
Linus Torvalds's avatar
Linus Torvalds committed
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
			if (is_lastmsg(i2c)) {
				/* last message, send stop and complete */
				dev_dbg(i2c->dev, "READ: Send Stop\n");

				s3c24xx_i2c_stop(i2c, 0);
			} else {
				/* go to the next transfer */
				dev_dbg(i2c->dev, "READ: Next Transfer\n");

				i2c->msg_ptr = 0;
				i2c->msg_idx++;
				i2c->msg++;
			}
		}

		break;
	}

	/* acknowlegde the IRQ and get back on with the work */

 out_ack:
547
	tmp = readl(i2c->regs + S3C2410_IICCON);
Linus Torvalds's avatar
Linus Torvalds committed
548
549
550
551
552
553
	tmp &= ~S3C2410_IICCON_IRQPEND;
	writel(tmp, i2c->regs + S3C2410_IICCON);
 out:
	return ret;
}

554
/*
Linus Torvalds's avatar
Linus Torvalds committed
555
 * top level IRQ servicing routine
556
 */
557
static irqreturn_t s3c24xx_i2c_irq(int irqno, void *dev_id)
Linus Torvalds's avatar
Linus Torvalds committed
558
559
560
561
562
563
564
565
{
	struct s3c24xx_i2c *i2c = dev_id;
	unsigned long status;
	unsigned long tmp;

	status = readl(i2c->regs + S3C2410_IICSTAT);

	if (status & S3C2410_IICSTAT_ARBITR) {
566
		/* deal with arbitration loss */
Linus Torvalds's avatar
Linus Torvalds committed
567
568
569
570
571
572
		dev_err(i2c->dev, "deal with arbitration loss\n");
	}

	if (i2c->state == STATE_IDLE) {
		dev_dbg(i2c->dev, "IRQ: error i2c->state == IDLE\n");

573
		tmp = readl(i2c->regs + S3C2410_IICCON);
Linus Torvalds's avatar
Linus Torvalds committed
574
575
576
577
		tmp &= ~S3C2410_IICCON_IRQPEND;
		writel(tmp, i2c->regs +  S3C2410_IICCON);
		goto out;
	}
578

579
580
581
582
	/*
	 * pretty much this leaves us with the fact that we've
	 * transmitted or received whatever byte we last sent
	 */
583
	i2c_s3c_irq_nextbyte(i2c, status);
Linus Torvalds's avatar
Linus Torvalds committed
584
585
586
587
588

 out:
	return IRQ_HANDLED;
}

589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
/*
 * Disable the bus so that we won't get any interrupts from now on, or try
 * to drive any lines. This is the default state when we don't have
 * anything to send/receive.
 *
 * If there is an event on the bus, or we have a pre-existing event at
 * kernel boot time, we may not notice the event and the I2C controller
 * will lock the bus with the I2C clock line low indefinitely.
 */
static inline void s3c24xx_i2c_disable_bus(struct s3c24xx_i2c *i2c)
{
	unsigned long tmp;

	/* Stop driving the I2C pins */
	tmp = readl(i2c->regs + S3C2410_IICSTAT);
	tmp &= ~S3C2410_IICSTAT_TXRXEN;
	writel(tmp, i2c->regs + S3C2410_IICSTAT);

	/* We don't expect any interrupts now, and don't want send acks */
	tmp = readl(i2c->regs + S3C2410_IICCON);
	tmp &= ~(S3C2410_IICCON_IRQEN | S3C2410_IICCON_IRQPEND |
		S3C2410_IICCON_ACKEN);
	writel(tmp, i2c->regs + S3C2410_IICCON);
}

Linus Torvalds's avatar
Linus Torvalds committed
614

615
/*
Linus Torvalds's avatar
Linus Torvalds committed
616
 * get the i2c bus for a master transaction
617
 */
Linus Torvalds's avatar
Linus Torvalds committed
618
619
620
621
622
623
624
static int s3c24xx_i2c_set_master(struct s3c24xx_i2c *i2c)
{
	unsigned long iicstat;
	int timeout = 400;

	while (timeout-- > 0) {
		iicstat = readl(i2c->regs + S3C2410_IICSTAT);
625

Linus Torvalds's avatar
Linus Torvalds committed
626
627
628
629
630
631
632
633
		if (!(iicstat & S3C2410_IICSTAT_BUSBUSY))
			return 0;

		msleep(1);
	}

	return -ETIMEDOUT;
}
634

635
/*
636
 * wait for the i2c bus to become idle.
637
 */
638
639
640
641
642
static void s3c24xx_i2c_wait_idle(struct s3c24xx_i2c *i2c)
{
	unsigned long iicstat;
	ktime_t start, now;
	unsigned long delay;
643
	int spins;
644
645
646
647
648
649
650
651
652
653
654
655

	/* ensure the stop has been through the bus */

	dev_dbg(i2c->dev, "waiting for bus idle\n");

	start = now = ktime_get();

	/*
	 * Most of the time, the bus is already idle within a few usec of the
	 * end of a transaction.  However, really slow i2c devices can stretch
	 * the clock, delaying STOP generation.
	 *
656
657
	 * On slower SoCs this typically happens within a very small number of
	 * instructions so busy wait briefly to avoid scheduling overhead.
658
	 */
659
	spins = 3;
660
	iicstat = readl(i2c->regs + S3C2410_IICSTAT);
661
662
663
	while ((iicstat & S3C2410_IICSTAT_START) && --spins) {
		cpu_relax();
		iicstat = readl(i2c->regs + S3C2410_IICSTAT);
664
665
	}

666
667
668
669
670
671
672
	/*
	 * If we do get an appreciable delay as a compromise between idle
	 * detection latency for the normal, fast case, and system load in the
	 * slow device case, use an exponential back off in the polling loop,
	 * up to 1/10th of the total timeout, then continue to poll at a
	 * constant rate up to the timeout.
	 */
673
674
675
676
677
678
679
680
681
682
683
684
	delay = 1;
	while ((iicstat & S3C2410_IICSTAT_START) &&
	       ktime_us_delta(now, start) < S3C2410_IDLE_TIMEOUT) {
		usleep_range(delay, 2 * delay);
		if (delay < S3C2410_IDLE_TIMEOUT / 10)
			delay <<= 1;
		now = ktime_get();
		iicstat = readl(i2c->regs + S3C2410_IICSTAT);
	}

	if (iicstat & S3C2410_IICSTAT_START)
		dev_warn(i2c->dev, "timeout waiting for bus idle\n");
Linus Torvalds's avatar
Linus Torvalds committed
685
686
}

687
/*
Linus Torvalds's avatar
Linus Torvalds committed
688
 * this starts an i2c transfer
689
 */
690
691
static int s3c24xx_i2c_doxfer(struct s3c24xx_i2c *i2c,
			      struct i2c_msg *msgs, int num)
Linus Torvalds's avatar
Linus Torvalds committed
692
{
693
	unsigned long timeout;
Linus Torvalds's avatar
Linus Torvalds committed
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
	int ret;

	ret = s3c24xx_i2c_set_master(i2c);
	if (ret != 0) {
		dev_err(i2c->dev, "cannot get bus (error %d)\n", ret);
		ret = -EAGAIN;
		goto out;
	}

	i2c->msg     = msgs;
	i2c->msg_num = num;
	i2c->msg_ptr = 0;
	i2c->msg_idx = 0;
	i2c->state   = STATE_START;

	s3c24xx_i2c_enable_irq(i2c);
	s3c24xx_i2c_message_start(i2c, msgs);
711

712
713
714
715
716
717
718
719
720
	if (i2c->quirks & QUIRK_POLL) {
		ret = i2c->msg_idx;

		if (ret != num)
			dev_dbg(i2c->dev, "incomplete xfer (%d)\n", ret);

		goto out;
	}

Linus Torvalds's avatar
Linus Torvalds committed
721
722
723
724
	timeout = wait_event_timeout(i2c->wait, i2c->msg_num == 0, HZ * 5);

	ret = i2c->msg_idx;

725
726
727
728
	/*
	 * Having these next two as dev_err() makes life very
	 * noisy when doing an i2cdetect
	 */
Linus Torvalds's avatar
Linus Torvalds committed
729
730
731
732
733
	if (timeout == 0)
		dev_dbg(i2c->dev, "timeout\n");
	else if (ret != num)
		dev_dbg(i2c->dev, "incomplete xfer (%d)\n", ret);

734
735
736
	/* For QUIRK_HDMIPHY, bus is already disabled */
	if (i2c->quirks & QUIRK_HDMIPHY)
		goto out;
737

738
	s3c24xx_i2c_wait_idle(i2c);
Linus Torvalds's avatar
Linus Torvalds committed
739

740
741
	s3c24xx_i2c_disable_bus(i2c);

Linus Torvalds's avatar
Linus Torvalds committed
742
 out:
743
744
	i2c->state = STATE_IDLE;

Linus Torvalds's avatar
Linus Torvalds committed
745
746
747
	return ret;
}

748
/*
Linus Torvalds's avatar
Linus Torvalds committed
749
 * first port of call from the i2c bus code when an message needs
750
 * transferring across the i2c bus.
751
 */
Linus Torvalds's avatar
Linus Torvalds committed
752
753
754
755
756
757
758
static int s3c24xx_i2c_xfer(struct i2c_adapter *adap,
			struct i2c_msg *msgs, int num)
{
	struct s3c24xx_i2c *i2c = (struct s3c24xx_i2c *)adap->algo_data;
	int retry;
	int ret;

759
760
761
	ret = clk_enable(i2c->clk);
	if (ret)
		return ret;
762

Linus Torvalds's avatar
Linus Torvalds committed
763
764
765
766
	for (retry = 0; retry < adap->retries; retry++) {

		ret = s3c24xx_i2c_doxfer(i2c, msgs, num);

767
		if (ret != -EAGAIN) {
768
			clk_disable(i2c->clk);
Linus Torvalds's avatar
Linus Torvalds committed
769
			return ret;
770
		}
Linus Torvalds's avatar
Linus Torvalds committed
771
772
773
774
775
776

		dev_dbg(i2c->dev, "Retrying transmission (%d)\n", retry);

		udelay(100);
	}

777
	clk_disable(i2c->clk);
Linus Torvalds's avatar
Linus Torvalds committed
778
779
780
781
782
783
	return -EREMOTEIO;
}

/* declare our i2c functionality */
static u32 s3c24xx_i2c_func(struct i2c_adapter *adap)
{
784
	return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL_ALL | I2C_FUNC_NOSTART |
785
		I2C_FUNC_PROTOCOL_MANGLING;
Linus Torvalds's avatar
Linus Torvalds committed
786
787
788
}

/* i2c bus registration info */
789
static const struct i2c_algorithm s3c24xx_i2c_algorithm = {
Linus Torvalds's avatar
Linus Torvalds committed
790
791
792
793
	.master_xfer		= s3c24xx_i2c_xfer,
	.functionality		= s3c24xx_i2c_func,
};

794
/*
Linus Torvalds's avatar
Linus Torvalds committed
795
 * return the divisor settings for a given frequency
796
 */
Linus Torvalds's avatar
Linus Torvalds committed
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
static int s3c24xx_i2c_calcdivisor(unsigned long clkin, unsigned int wanted,
				   unsigned int *div1, unsigned int *divs)
{
	unsigned int calc_divs = clkin / wanted;
	unsigned int calc_div1;

	if (calc_divs > (16*16))
		calc_div1 = 512;
	else
		calc_div1 = 16;

	calc_divs += calc_div1-1;
	calc_divs /= calc_div1;

	if (calc_divs == 0)
		calc_divs = 1;
	if (calc_divs > 17)
		calc_divs = 17;

	*divs = calc_divs;
	*div1 = calc_div1;

	return clkin / (calc_divs * calc_div1);
}

822
/*
Linus Torvalds's avatar
Linus Torvalds committed
823
824
825
 * work out a divisor for the user requested frequency setting,
 * either by the requested frequency, or scanning the acceptable
 * range of frequencies until something is found
826
 */
827
static int s3c24xx_i2c_clockrate(struct s3c24xx_i2c *i2c, unsigned int *got)
Linus Torvalds's avatar
Linus Torvalds committed
828
{
829
	struct s3c2410_platform_i2c *pdata = i2c->pdata;
Linus Torvalds's avatar
Linus Torvalds committed
830
831
	unsigned long clkin = clk_get_rate(i2c->clk);
	unsigned int divs, div1;
832
	unsigned long target_frequency;
833
	u32 iiccon;
Linus Torvalds's avatar
Linus Torvalds committed
834
835
	int freq;

836
	i2c->clkrate = clkin;
837
	clkin /= 1000;	/* clkin now in KHz */
838

839
	dev_dbg(i2c->dev, "pdata desired frequency %lu\n", pdata->frequency);
Linus Torvalds's avatar
Linus Torvalds committed
840

841
	target_frequency = pdata->frequency ?: I2C_MAX_STANDARD_MODE_FREQ;
Linus Torvalds's avatar
Linus Torvalds committed
842

843
	target_frequency /= 1000; /* Target frequency now in KHz */
Linus Torvalds's avatar
Linus Torvalds committed
844

845
	freq = s3c24xx_i2c_calcdivisor(clkin, target_frequency, &div1, &divs);
Linus Torvalds's avatar
Linus Torvalds committed
846

847
848
849
850
851
	if (freq > target_frequency) {
		dev_err(i2c->dev,
			"Unable to achieve desired frequency %luKHz."	\
			" Lowest achievable %dKHz\n", target_frequency, freq);
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
852
853
854
	}

	*got = freq;
855
856
857
858
859
860
861
862

	iiccon = readl(i2c->regs + S3C2410_IICCON);
	iiccon &= ~(S3C2410_IICCON_SCALEMASK | S3C2410_IICCON_TXDIV_512);
	iiccon |= (divs-1);

	if (div1 == 512)
		iiccon |= S3C2410_IICCON_TXDIV_512;

863
864
865
	if (i2c->quirks & QUIRK_POLL)
		iiccon |= S3C2410_IICCON_SCALE(2);

866
867
	writel(iiccon, i2c->regs + S3C2410_IICCON);

868
	if (i2c->quirks & QUIRK_S3C2440) {
869
870
871
		unsigned long sda_delay;

		if (pdata->sda_delay) {
872
873
			sda_delay = clkin * pdata->sda_delay;
			sda_delay = DIV_ROUND_UP(sda_delay, 1000000);
874
875
876
877
878
879
880
881
882
883
884
			sda_delay = DIV_ROUND_UP(sda_delay, 5);
			if (sda_delay > 3)
				sda_delay = 3;
			sda_delay |= S3C2410_IICLC_FILTER_ON;
		} else
			sda_delay = 0;

		dev_dbg(i2c->dev, "IICLC=%08lx\n", sda_delay);
		writel(sda_delay, i2c->regs + S3C2440_IICLC);
	}

885
886
887
	return 0;
}

888
#if defined(CONFIG_ARM_S3C24XX_CPUFREQ)
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908

#define freq_to_i2c(_n) container_of(_n, struct s3c24xx_i2c, freq_transition)

static int s3c24xx_i2c_cpufreq_transition(struct notifier_block *nb,
					  unsigned long val, void *data)
{
	struct s3c24xx_i2c *i2c = freq_to_i2c(nb);
	unsigned int got;
	int delta_f;
	int ret;

	delta_f = clk_get_rate(i2c->clk) - i2c->clkrate;

	/* if we're post-change and the input clock has slowed down
	 * or at pre-change and the clock is about to speed up, then
	 * adjust our clock rate. <0 is slow, >0 speedup.
	 */

	if ((val == CPUFREQ_POSTCHANGE && delta_f < 0) ||
	    (val == CPUFREQ_PRECHANGE && delta_f > 0)) {
909
		i2c_lock_bus(&i2c->adap, I2C_LOCK_ROOT_ADAPTER);
910
		ret = s3c24xx_i2c_clockrate(i2c, &got);
911
		i2c_unlock_bus(&i2c->adap, I2C_LOCK_ROOT_ADAPTER);
912
913

		if (ret < 0)
914
			dev_err(i2c->dev, "cannot find frequency (%d)\n", ret);
915
916
917
918
		else
			dev_info(i2c->dev, "setting freq %d\n", got);
	}

Linus Torvalds's avatar
Linus Torvalds committed
919
920
921
	return 0;
}

922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
static inline int s3c24xx_i2c_register_cpufreq(struct s3c24xx_i2c *i2c)
{
	i2c->freq_transition.notifier_call = s3c24xx_i2c_cpufreq_transition;

	return cpufreq_register_notifier(&i2c->freq_transition,
					 CPUFREQ_TRANSITION_NOTIFIER);
}

static inline void s3c24xx_i2c_deregister_cpufreq(struct s3c24xx_i2c *i2c)
{
	cpufreq_unregister_notifier(&i2c->freq_transition,
				    CPUFREQ_TRANSITION_NOTIFIER);
}

#else
static inline int s3c24xx_i2c_register_cpufreq(struct s3c24xx_i2c *i2c)
{
Linus Torvalds's avatar
Linus Torvalds committed
939
940
941
	return 0;
}

942
943
944
945
946
static inline void s3c24xx_i2c_deregister_cpufreq(struct s3c24xx_i2c *i2c)
{
}
#endif

947
948
949
#ifdef CONFIG_OF
static int s3c24xx_i2c_parse_dt_gpio(struct s3c24xx_i2c *i2c)
{
950
	int i;
951

952
953
954
	if (i2c->quirks & QUIRK_NO_GPIO)
		return 0;

955
956
957
958
959
960
	for (i = 0; i < 2; i++) {
		i2c->gpios[i] = devm_gpiod_get_index(i2c->dev, NULL,
						     i, GPIOD_ASIS);
		if (IS_ERR(i2c->gpios[i])) {
			dev_err(i2c->dev, "i2c gpio invalid at index %d\n", i);
			return -EINVAL;
961
962
963
964
965
966
967
968
		}
	}
	return 0;
}

#else
static int s3c24xx_i2c_parse_dt_gpio(struct s3c24xx_i2c *i2c)
{
969
	return 0;
970
971
972
}
#endif

973
/*
974
 * initialise the controller, set the IO lines and frequency
975
 */
Linus Torvalds's avatar
Linus Torvalds committed
976
977
978
979
980
981
982
static int s3c24xx_i2c_init(struct s3c24xx_i2c *i2c)
{
	struct s3c2410_platform_i2c *pdata;
	unsigned int freq;

	/* get the plafrom data */

983
	pdata = i2c->pdata;
Linus Torvalds's avatar
Linus Torvalds committed
984
985

	/* write slave address */
986

Linus Torvalds's avatar
Linus Torvalds committed
987
988
989
990
	writeb(pdata->slave_addr, i2c->regs + S3C2410_IICADD);

	dev_info(i2c->dev, "slave address 0x%02x\n", pdata->slave_addr);

991
992
	writel(0, i2c->regs + S3C2410_IICCON);
	writel(0, i2c->regs + S3C2410_IICSTAT);
993

Linus Torvalds's avatar
Linus Torvalds committed
994
995
	/* we need to work out the divisors for the clock... */

996
	if (s3c24xx_i2c_clockrate(i2c, &freq) != 0) {
Linus Torvalds's avatar
Linus Torvalds committed
997
998
999
1000
1001
1002
1003
		dev_err(i2c->dev, "cannot meet bus frequency required\n");
		return -EINVAL;
	}

	/* todo - check that the i2c lines aren't being dragged anywhere */

	dev_info(i2c->dev, "bus frequency set to %d KHz\n", freq);
1004
1005
	dev_dbg(i2c->dev, "S3C2410_IICCON=0x%02x\n",
		readl(i2c->regs + S3C2410_IICCON));
Linus Torvalds's avatar
Linus Torvalds committed
1006
1007
1008
1009

	return 0;
}

1010
#ifdef CONFIG_OF
1011
/*
1012
 * Parse the device tree node and retreive the platform data.
1013
 */
1014
1015
1016
1017
static void
s3c24xx_i2c_parse_dt(struct device_node *np, struct s3c24xx_i2c *i2c)
{
	struct s3c2410_platform_i2c *pdata = i2c->pdata;
1018
	int id;
1019
1020
1021
1022
1023
1024
1025
1026
1027

	if (!np)
		return;

	pdata->bus_num = -1; /* i2c bus number is dynamically assigned */
	of_property_read_u32(np, "samsung,i2c-sda-delay", &pdata->sda_delay);
	of_property_read_u32(np, "samsung,i2c-slave-addr", &pdata->slave_addr);
	of_property_read_u32(np, "samsung,i2c-max-bus-freq",
				(u32 *)&pdata->frequency);
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
	/*
	 * Exynos5's legacy i2c controller and new high speed i2c
	 * controller have muxed interrupt sources. By default the
	 * interrupts for 4-channel HS-I2C controller are enabled.
	 * If nodes for first four channels of legacy i2c controller
	 * are available then re-configure the interrupts via the
	 * system register.
	 */
	id = of_alias_get_id(np, "i2c");
	i2c->sysreg = syscon_regmap_lookup_by_phandle(np,
			"samsung,sysreg-phandle");
	if (IS_ERR(i2c->sysreg))
		return;

	regmap_update_bits(i2c->sysreg, EXYNOS5_SYS_I2C_CFG, BIT(id), 0);
1043
1044
1045
}
#else
static void
1046
s3c24xx_i2c_parse_dt(struct device_node *np, struct s3c24xx_i2c *i2c) { }
1047
1048
#endif

1049
static int s3c24xx_i2c_probe(struct platform_device *pdev)
Linus Torvalds's avatar
Linus Torvalds committed
1050
{
1051
	struct s3c24xx_i2c *i2c;
1052
	struct s3c2410_platform_i2c *pdata = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
1053
1054
1055
	struct resource *res;
	int ret;

1056
	if (!pdev->dev.of_node) {
Jingoo Han's avatar
Jingoo Han committed
1057
		pdata = dev_get_platdata(&pdev->dev);
1058
1059
1060
1061
		if (!pdata) {
			dev_err(&pdev->dev, "no platform data\n");
			return -EINVAL;
		}
1062
	}
1063

1064
	i2c = devm_kzalloc(&pdev->dev, sizeof(struct s3c24xx_i2c), GFP_KERNEL);
1065
	if (!i2c)
1066
1067
		return -ENOMEM;

1068
	i2c->pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
1069
	if (!i2c->pdata)
1070
		return -ENOMEM;
1071

1072
	i2c->quirks = s3c24xx_get_device_quirks(pdev);
1073
	i2c->sysreg = ERR_PTR(-ENOENT);
1074
1075
	if (pdata)
		memcpy(i2c->pdata, pdata, sizeof(*pdata));
1076
1077
	else
		s3c24xx_i2c_parse_dt(pdev->dev.of_node, i2c);
1078

1079
	strlcpy(i2c->adap.name, "s3c2410-i2c", sizeof(i2c->adap.name));
1080
1081
	i2c->adap.owner = THIS_MODULE;
	i2c->adap.algo = &s3c24xx_i2c_algorithm;
1082
	i2c->adap.retries = 2;
1083
1084
	i2c->adap.class = I2C_CLASS_DEPRECATED;
	i2c->tx_setup = 50;
1085
1086

	init_waitqueue_head(&i2c->wait);
1087

Linus Torvalds's avatar
Linus Torvalds committed
1088
	/* find the clock and enable it */
1089
	i2c->dev = &pdev->dev;
1090
	i2c->clk = devm_clk_get(&pdev->dev, "i2c");
Linus Torvalds's avatar
Linus Torvalds committed
1091
	if (IS_ERR(i2c->clk)) {
1092
		dev_err(&pdev->dev, "cannot get clock\n");
1093
		return -ENOENT;
Linus Torvalds's avatar
Linus Torvalds committed
1094
1095
	}

1096
	dev_dbg(&pdev->dev, "clock source %p\n", i2c->clk);
Linus Torvalds's avatar
Linus Torvalds committed
1097
1098
1099

	/* map the registers */
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1100
	i2c->regs = devm_ioremap_resource(&pdev->dev, res);
Linus Torvalds's avatar
Linus Torvalds committed
1101

1102
1103
	if (IS_ERR(i2c->regs))
		return PTR_ERR(i2c->regs);
Linus Torvalds's avatar
Linus Torvalds committed
1104

1105
1106
	dev_dbg(&pdev->dev, "registers %p (%p)\n",
		i2c->regs, res);
Linus Torvalds's avatar
Linus Torvalds committed
1107
1108
1109

	/* setup info block for the i2c core */
	i2c->adap.algo_data = i2c;
1110
	i2c->adap.dev.parent = &pdev->dev;
1111
1112
	i2c->pctrl = devm_pinctrl_get_select_default(i2c->dev);

1113
	/* inititalise the i2c gpio lines */
1114
	if (i2c->pdata->cfg_gpio)
1115
		i2c->pdata->cfg_gpio(to_platform_device(i2c->dev));
1116
	else if (IS_ERR(i2c->pctrl) && s3c24xx_i2c_parse_dt_gpio(i2c))
1117
		return -EINVAL;
1118

Linus Torvalds's avatar
Linus Torvalds committed
1119
	/* initialise the i2c controller */
1120
1121
1122
1123
1124
1125
	ret = clk_prepare_enable(i2c->clk);
	if (ret) {
		dev_err(&pdev->dev, "I2C clock enable failed\n");
		return ret;
	}

Linus Torvalds's avatar
Linus Torvalds committed
1126
	ret = s3c24xx_i2c_init(i2c);
1127
	clk_disable(i2c->clk);
1128
1129
	if (ret != 0) {
		dev_err(&pdev->dev, "I2C controller init failed\n");
1130
		clk_unprepare(i2c->clk);
1131
1132
		return ret;
	}
1133
1134
1135

	/*
	 * find the IRQ for this unit (note, this relies on the init call to
1136
	 * ensure no current IRQs pending
Linus Torvalds's avatar
Linus Torvalds committed
1137
	 */
1138
1139
1140
1141
	if (!(i2c->quirks & QUIRK_POLL)) {
		i2c->irq = ret = platform_get_irq(pdev, 0);
		if (ret <= 0) {
			dev_err(&pdev->dev, "cannot find IRQ\n");
1142
			clk_unprepare(i2c->clk);
1143
1144
			return ret;
		}
Linus Torvalds's avatar
Linus Torvalds committed
1145

1146
1147
		ret = devm_request_irq(&pdev->dev, i2c->irq, s3c24xx_i2c_irq,
				       0, dev_name(&pdev->dev), i2c);
1148
1149
		if (ret != 0) {
			dev_err(&pdev->dev, "cannot claim IRQ %d\n", i2c->irq);
1150
			clk_unprepare(i2c->clk);
1151
1152
			return ret;
		}
Linus Torvalds's avatar
Linus Torvalds committed
1153
1154
	}

1155
	ret = s3c24xx_i2c_register_cpufreq(i2c);
Linus Torvalds's avatar
Linus Torvalds committed
1156
	if (ret < 0) {
1157
		dev_err(&pdev->dev, "failed to register cpufreq notifier\n");
1158
		clk_unprepare(i2c->clk);
1159
		return ret;
Linus Torvalds's avatar
Linus Torvalds committed
1160