blob: 3747b9bf67d6440f684bcff945a2a85b93f6fe6c [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>
Thomas Abraham5a5f5082011-09-13 09:46:05 +053039#include <linux/of_gpio.h>
Tomasz Figa2693ac62012-11-13 11:33:40 +010040#include <linux/pinctrl/consumer.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include <asm/irq.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043
Arnd Bergmann436d42c2012-08-24 15:22:12 +020044#include <linux/platform_data/i2c-s3c2410.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
Heiko Stübnere6366022013-03-21 04:09:25 +000046/* see s3c2410x user guide, v1.1, section 9 (p447) for more info */
47
Heiko Stübner7a6674d2013-03-21 04:10:13 +000048#define S3C2410_IICCON 0x00
49#define S3C2410_IICSTAT 0x04
50#define S3C2410_IICADD 0x08
51#define S3C2410_IICDS 0x0C
52#define S3C2440_IICLC 0x10
Heiko Stübnere6366022013-03-21 04:09:25 +000053
Heiko Stübner7a6674d2013-03-21 04:10:13 +000054#define S3C2410_IICCON_ACKEN (1 << 7)
55#define S3C2410_IICCON_TXDIV_16 (0 << 6)
56#define S3C2410_IICCON_TXDIV_512 (1 << 6)
57#define S3C2410_IICCON_IRQEN (1 << 5)
58#define S3C2410_IICCON_IRQPEND (1 << 4)
59#define S3C2410_IICCON_SCALE(x) ((x) & 0xf)
Heiko Stübnere6366022013-03-21 04:09:25 +000060#define S3C2410_IICCON_SCALEMASK (0xf)
61
Heiko Stübner7a6674d2013-03-21 04:10:13 +000062#define S3C2410_IICSTAT_MASTER_RX (2 << 6)
63#define S3C2410_IICSTAT_MASTER_TX (3 << 6)
64#define S3C2410_IICSTAT_SLAVE_RX (0 << 6)
65#define S3C2410_IICSTAT_SLAVE_TX (1 << 6)
66#define S3C2410_IICSTAT_MODEMASK (3 << 6)
Heiko Stübnere6366022013-03-21 04:09:25 +000067
Heiko Stübner7a6674d2013-03-21 04:10:13 +000068#define S3C2410_IICSTAT_START (1 << 5)
69#define S3C2410_IICSTAT_BUSBUSY (1 << 5)
70#define S3C2410_IICSTAT_TXRXEN (1 << 4)
71#define S3C2410_IICSTAT_ARBITR (1 << 3)
72#define S3C2410_IICSTAT_ASSLAVE (1 << 2)
73#define S3C2410_IICSTAT_ADDR0 (1 << 1)
74#define S3C2410_IICSTAT_LASTBIT (1 << 0)
Heiko Stübnere6366022013-03-21 04:09:25 +000075
76#define S3C2410_IICLC_SDA_DELAY0 (0 << 0)
77#define S3C2410_IICLC_SDA_DELAY5 (1 << 0)
78#define S3C2410_IICLC_SDA_DELAY10 (2 << 0)
79#define S3C2410_IICLC_SDA_DELAY15 (3 << 0)
80#define S3C2410_IICLC_SDA_DELAY_MASK (3 << 0)
81
Heiko Stübner7a6674d2013-03-21 04:10:13 +000082#define S3C2410_IICLC_FILTER_ON (1 << 2)
Heiko Stübnere6366022013-03-21 04:09:25 +000083
Karol Lewandowski27452492012-04-23 18:24:00 +020084/* Treat S3C2410 as baseline hardware, anything else is supported via quirks */
85#define QUIRK_S3C2440 (1 << 0)
Karol Lewandowskiec39ef82012-04-23 18:24:01 +020086#define QUIRK_HDMIPHY (1 << 1)
87#define QUIRK_NO_GPIO (1 << 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
Daniel Kurtzfe724bf2012-11-15 17:43:32 +053089/* Max time to wait for bus to become idle after a xfer (in us) */
90#define S3C2410_IDLE_TIMEOUT 5000
91
Karol Lewandowski27452492012-04-23 18:24:00 +020092/* i2c controller state */
Linus Torvalds1da177e2005-04-16 15:20:36 -070093enum s3c24xx_i2c_state {
94 STATE_IDLE,
95 STATE_START,
96 STATE_READ,
97 STATE_WRITE,
98 STATE_STOP
99};
100
101struct s3c24xx_i2c {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 wait_queue_head_t wait;
Karol Lewandowski27452492012-04-23 18:24:00 +0200103 unsigned int quirks;
Ben Dooksbe44f012008-10-31 16:10:22 +0000104 unsigned int suspended:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105
106 struct i2c_msg *msg;
107 unsigned int msg_num;
108 unsigned int msg_idx;
109 unsigned int msg_ptr;
110
Ben Dookse00a8cd2007-05-01 23:26:35 +0200111 unsigned int tx_setup;
Ben Dookse0d1ec92008-10-31 16:10:30 +0000112 unsigned int irq;
Ben Dookse00a8cd2007-05-01 23:26:35 +0200113
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 enum s3c24xx_i2c_state state;
Ben Dooks61c7cff2008-07-28 12:04:07 +0100115 unsigned long clkrate;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116
117 void __iomem *regs;
118 struct clk *clk;
119 struct device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 struct i2c_adapter adap;
Ben Dooks61c7cff2008-07-28 12:04:07 +0100121
Thomas Abraham4fd81eb2011-09-13 09:46:04 +0530122 struct s3c2410_platform_i2c *pdata;
Thomas Abraham5a5f5082011-09-13 09:46:05 +0530123 int gpios[2];
Tomasz Figa2693ac62012-11-13 11:33:40 +0100124 struct pinctrl *pctrl;
Ben Dooks61c7cff2008-07-28 12:04:07 +0100125#ifdef CONFIG_CPU_FREQ
126 struct notifier_block freq_transition;
127#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128};
129
Karol Lewandowski27452492012-04-23 18:24:00 +0200130static struct platform_device_id s3c24xx_driver_ids[] = {
131 {
132 .name = "s3c2410-i2c",
133 .driver_data = 0,
134 }, {
135 .name = "s3c2440-i2c",
136 .driver_data = QUIRK_S3C2440,
Karol Lewandowskiec39ef82012-04-23 18:24:01 +0200137 }, {
138 .name = "s3c2440-hdmiphy-i2c",
139 .driver_data = QUIRK_S3C2440 | QUIRK_HDMIPHY | QUIRK_NO_GPIO,
Karol Lewandowski27452492012-04-23 18:24:00 +0200140 }, { },
141};
142MODULE_DEVICE_TABLE(platform, s3c24xx_driver_ids);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143
Thomas Abraham5a5f5082011-09-13 09:46:05 +0530144#ifdef CONFIG_OF
Karol Lewandowski27452492012-04-23 18:24:00 +0200145static const struct of_device_id s3c24xx_i2c_match[] = {
146 { .compatible = "samsung,s3c2410-i2c", .data = (void *)0 },
147 { .compatible = "samsung,s3c2440-i2c", .data = (void *)QUIRK_S3C2440 },
Karol Lewandowskiec39ef82012-04-23 18:24:01 +0200148 { .compatible = "samsung,s3c2440-hdmiphy-i2c",
149 .data = (void *)(QUIRK_S3C2440 | QUIRK_HDMIPHY | QUIRK_NO_GPIO) },
Giridhar Maruthyfaf93ff2013-01-24 11:27:51 -0800150 { .compatible = "samsung,exynos5440-i2c",
151 .data = (void *)(QUIRK_S3C2440 | QUIRK_NO_GPIO) },
Karol Lewandowski27452492012-04-23 18:24:00 +0200152 {},
153};
154MODULE_DEVICE_TABLE(of, s3c24xx_i2c_match);
Thomas Abraham5a5f5082011-09-13 09:46:05 +0530155#endif
156
Karol Lewandowski27452492012-04-23 18:24:00 +0200157/* s3c24xx_get_device_quirks
158 *
159 * Get controller type either from device tree or platform device variant.
160*/
161
162static inline unsigned int s3c24xx_get_device_quirks(struct platform_device *pdev)
163{
164 if (pdev->dev.of_node) {
165 const struct of_device_id *match;
Karol Lewandowskib900ba42012-05-30 11:43:05 +0200166 match = of_match_node(s3c24xx_i2c_match, pdev->dev.of_node);
Karol Lewandowski27452492012-04-23 18:24:00 +0200167 return (unsigned int)match->data;
168 }
169
170 return platform_get_device_id(pdev)->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171}
172
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173/* s3c24xx_i2c_master_complete
174 *
175 * complete the message and wake up the caller, using the given return code,
176 * or zero to mean ok.
177*/
178
179static inline void s3c24xx_i2c_master_complete(struct s3c24xx_i2c *i2c, int ret)
180{
181 dev_dbg(i2c->dev, "master_complete %d\n", ret);
182
183 i2c->msg_ptr = 0;
184 i2c->msg = NULL;
Ben Dooks3d0911b2008-10-31 16:10:24 +0000185 i2c->msg_idx++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 i2c->msg_num = 0;
187 if (ret)
188 i2c->msg_idx = ret;
189
190 wake_up(&i2c->wait);
191}
192
193static inline void s3c24xx_i2c_disable_ack(struct s3c24xx_i2c *i2c)
194{
195 unsigned long tmp;
Ben Dooks3d0911b2008-10-31 16:10:24 +0000196
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 tmp = readl(i2c->regs + S3C2410_IICCON);
198 writel(tmp & ~S3C2410_IICCON_ACKEN, i2c->regs + S3C2410_IICCON);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199}
200
201static inline void s3c24xx_i2c_enable_ack(struct s3c24xx_i2c *i2c)
202{
203 unsigned long tmp;
Ben Dooks3d0911b2008-10-31 16:10:24 +0000204
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 tmp = readl(i2c->regs + S3C2410_IICCON);
206 writel(tmp | S3C2410_IICCON_ACKEN, i2c->regs + S3C2410_IICCON);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207}
208
209/* irq enable/disable functions */
210
211static inline void s3c24xx_i2c_disable_irq(struct s3c24xx_i2c *i2c)
212{
213 unsigned long tmp;
Ben Dooks3d0911b2008-10-31 16:10:24 +0000214
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 tmp = readl(i2c->regs + S3C2410_IICCON);
216 writel(tmp & ~S3C2410_IICCON_IRQEN, i2c->regs + S3C2410_IICCON);
217}
218
219static inline void s3c24xx_i2c_enable_irq(struct s3c24xx_i2c *i2c)
220{
221 unsigned long tmp;
Ben Dooks3d0911b2008-10-31 16:10:24 +0000222
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 tmp = readl(i2c->regs + S3C2410_IICCON);
224 writel(tmp | S3C2410_IICCON_IRQEN, i2c->regs + S3C2410_IICCON);
225}
226
227
228/* s3c24xx_i2c_message_start
229 *
Ben Dooks3d0911b2008-10-31 16:10:24 +0000230 * put the start of a message onto the bus
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231*/
232
Ben Dooks3d0911b2008-10-31 16:10:24 +0000233static void s3c24xx_i2c_message_start(struct s3c24xx_i2c *i2c,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 struct i2c_msg *msg)
235{
236 unsigned int addr = (msg->addr & 0x7f) << 1;
237 unsigned long stat;
238 unsigned long iiccon;
239
240 stat = 0;
241 stat |= S3C2410_IICSTAT_TXRXEN;
242
243 if (msg->flags & I2C_M_RD) {
244 stat |= S3C2410_IICSTAT_MASTER_RX;
245 addr |= 1;
246 } else
247 stat |= S3C2410_IICSTAT_MASTER_TX;
248
249 if (msg->flags & I2C_M_REV_DIR_ADDR)
250 addr ^= 1;
251
Adam Buchbinder48fc7f72012-09-19 21:48:00 -0400252 /* todo - check for whether ack wanted or not */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 s3c24xx_i2c_enable_ack(i2c);
254
255 iiccon = readl(i2c->regs + S3C2410_IICCON);
256 writel(stat, i2c->regs + S3C2410_IICSTAT);
Ben Dooks3d0911b2008-10-31 16:10:24 +0000257
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 dev_dbg(i2c->dev, "START: %08lx to IICSTAT, %02x to DS\n", stat, addr);
259 writeb(addr, i2c->regs + S3C2410_IICDS);
Ben Dooks3d0911b2008-10-31 16:10:24 +0000260
Ben Dookse00a8cd2007-05-01 23:26:35 +0200261 /* delay here to ensure the data byte has gotten onto the bus
262 * before the transaction is started */
263
264 ndelay(i2c->tx_setup);
265
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 dev_dbg(i2c->dev, "iiccon, %08lx\n", iiccon);
267 writel(iiccon, i2c->regs + S3C2410_IICCON);
Ben Dooks3d0911b2008-10-31 16:10:24 +0000268
269 stat |= S3C2410_IICSTAT_START;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 writel(stat, i2c->regs + S3C2410_IICSTAT);
271}
272
273static inline void s3c24xx_i2c_stop(struct s3c24xx_i2c *i2c, int ret)
274{
275 unsigned long iicstat = readl(i2c->regs + S3C2410_IICSTAT);
276
277 dev_dbg(i2c->dev, "STOP\n");
278
Daniel Kurtz0da2e772012-11-15 17:43:31 +0530279 /*
280 * The datasheet says that the STOP sequence should be:
281 * 1) I2CSTAT.5 = 0 - Clear BUSY (or 'generate STOP')
282 * 2) I2CCON.4 = 0 - Clear IRQPEND
283 * 3) Wait until the stop condition takes effect.
284 * 4*) I2CSTAT.4 = 0 - Clear TXRXEN
285 *
286 * Where, step "4*" is only for buses with the "HDMIPHY" quirk.
287 *
288 * However, after much experimentation, it appears that:
289 * a) normal buses automatically clear BUSY and transition from
290 * Master->Slave when they complete generating a STOP condition.
291 * Therefore, step (3) can be done in doxfer() by polling I2CCON.4
292 * after starting the STOP generation here.
293 * b) HDMIPHY bus does neither, so there is no way to do step 3.
294 * There is no indication when this bus has finished generating
295 * STOP.
296 *
297 * In fact, we have found that as soon as the IRQPEND bit is cleared in
298 * step 2, the HDMIPHY bus generates the STOP condition, and then
299 * immediately starts transferring another data byte, even though the
300 * bus is supposedly stopped. This is presumably because the bus is
301 * still in "Master" mode, and its BUSY bit is still set.
302 *
303 * To avoid these extra post-STOP transactions on HDMI phy devices, we
304 * just disable Serial Output on the bus (I2CSTAT.4 = 0) directly,
305 * instead of first generating a proper STOP condition. This should
306 * float SDA & SCK terminating the transfer. Subsequent transfers
307 * start with a proper START condition, and proceed normally.
308 *
309 * The HDMIPHY bus is an internal bus that always has exactly two
310 * devices, the host as Master and the HDMIPHY device as the slave.
311 * Skipping the STOP condition has been tested on this bus and works.
312 */
313 if (i2c->quirks & QUIRK_HDMIPHY) {
314 /* Stop driving the I2C pins */
315 iicstat &= ~S3C2410_IICSTAT_TXRXEN;
316 } else {
317 /* stop the transfer */
318 iicstat &= ~S3C2410_IICSTAT_START;
319 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 writel(iicstat, i2c->regs + S3C2410_IICSTAT);
Ben Dooks3d0911b2008-10-31 16:10:24 +0000321
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 i2c->state = STATE_STOP;
Ben Dooks3d0911b2008-10-31 16:10:24 +0000323
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 s3c24xx_i2c_master_complete(i2c, ret);
325 s3c24xx_i2c_disable_irq(i2c);
326}
327
328/* helper functions to determine the current state in the set of
329 * messages we are sending */
330
331/* is_lastmsg()
332 *
Ben Dooks3d0911b2008-10-31 16:10:24 +0000333 * returns TRUE if the current message is the last in the set
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334*/
335
336static inline int is_lastmsg(struct s3c24xx_i2c *i2c)
337{
338 return i2c->msg_idx >= (i2c->msg_num - 1);
339}
340
341/* is_msglast
342 *
343 * returns TRUE if we this is the last byte in the current message
344*/
345
346static inline int is_msglast(struct s3c24xx_i2c *i2c)
347{
Jaemin Yoo857473112013-03-26 04:29:56 +0000348 /* msg->len is always 1 for the first byte of smbus block read.
349 * Actual length will be read from slave. More bytes will be
350 * read according to the length then. */
351 if (i2c->msg->flags & I2C_M_RECV_LEN && i2c->msg->len == 1)
352 return 0;
353
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 return i2c->msg_ptr == i2c->msg->len-1;
355}
356
357/* is_msgend
358 *
359 * returns TRUE if we reached the end of the current message
360*/
361
362static inline int is_msgend(struct s3c24xx_i2c *i2c)
363{
364 return i2c->msg_ptr >= i2c->msg->len;
365}
366
Huisung Kang19820512011-06-23 21:37:33 +0900367/* i2c_s3c_irq_nextbyte
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 *
369 * process an interrupt and work out what to do
370 */
371
Huisung Kang19820512011-06-23 21:37:33 +0900372static int i2c_s3c_irq_nextbyte(struct s3c24xx_i2c *i2c, unsigned long iicstat)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373{
374 unsigned long tmp;
375 unsigned char byte;
376 int ret = 0;
377
378 switch (i2c->state) {
379
380 case STATE_IDLE:
Harvey Harrison08882d22008-04-22 22:16:47 +0200381 dev_err(i2c->dev, "%s: called in STATE_IDLE\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383
384 case STATE_STOP:
Harvey Harrison08882d22008-04-22 22:16:47 +0200385 dev_err(i2c->dev, "%s: called in STATE_STOP\n", __func__);
Ben Dooks3d0911b2008-10-31 16:10:24 +0000386 s3c24xx_i2c_disable_irq(i2c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 goto out_ack;
388
389 case STATE_START:
390 /* last thing we did was send a start condition on the
391 * bus, or started a new i2c message
392 */
Ben Dooks3d0911b2008-10-31 16:10:24 +0000393
Ben Dooks63f5c282008-07-01 11:59:42 +0100394 if (iicstat & S3C2410_IICSTAT_LASTBIT &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 !(i2c->msg->flags & I2C_M_IGNORE_NAK)) {
396 /* ack was not received... */
397
398 dev_dbg(i2c->dev, "ack was not received\n");
Ben Dooks63f5c282008-07-01 11:59:42 +0100399 s3c24xx_i2c_stop(i2c, -ENXIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 goto out_ack;
401 }
402
403 if (i2c->msg->flags & I2C_M_RD)
404 i2c->state = STATE_READ;
405 else
406 i2c->state = STATE_WRITE;
407
408 /* terminate the transfer if there is nothing to do
Ben Dooks63f5c282008-07-01 11:59:42 +0100409 * as this is used by the i2c probe to find devices. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410
411 if (is_lastmsg(i2c) && i2c->msg->len == 0) {
412 s3c24xx_i2c_stop(i2c, 0);
413 goto out_ack;
414 }
415
416 if (i2c->state == STATE_READ)
417 goto prepare_read;
418
Ben Dooks3d0911b2008-10-31 16:10:24 +0000419 /* fall through to the write state, as we will need to
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 * send a byte as well */
421
422 case STATE_WRITE:
423 /* we are writing data to the device... check for the
424 * end of the message, and if so, work out what to do
425 */
426
Ben Dooks27097812008-07-01 11:59:41 +0100427 if (!(i2c->msg->flags & I2C_M_IGNORE_NAK)) {
428 if (iicstat & S3C2410_IICSTAT_LASTBIT) {
429 dev_dbg(i2c->dev, "WRITE: No Ack\n");
430
431 s3c24xx_i2c_stop(i2c, -ECONNREFUSED);
432 goto out_ack;
433 }
434 }
435
Ben Dooks3d0911b2008-10-31 16:10:24 +0000436 retry_write:
Ben Dooks27097812008-07-01 11:59:41 +0100437
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 if (!is_msgend(i2c)) {
439 byte = i2c->msg->buf[i2c->msg_ptr++];
440 writeb(byte, i2c->regs + S3C2410_IICDS);
Ben Dookse00a8cd2007-05-01 23:26:35 +0200441
442 /* delay after writing the byte to allow the
443 * data setup time on the bus, as writing the
444 * data to the register causes the first bit
445 * to appear on SDA, and SCL will change as
446 * soon as the interrupt is acknowledged */
447
448 ndelay(i2c->tx_setup);
449
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 } else if (!is_lastmsg(i2c)) {
451 /* we need to go to the next i2c message */
452
453 dev_dbg(i2c->dev, "WRITE: Next Message\n");
454
455 i2c->msg_ptr = 0;
Ben Dooks3d0911b2008-10-31 16:10:24 +0000456 i2c->msg_idx++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 i2c->msg++;
Ben Dooks3d0911b2008-10-31 16:10:24 +0000458
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 /* check to see if we need to do another message */
460 if (i2c->msg->flags & I2C_M_NOSTART) {
461
462 if (i2c->msg->flags & I2C_M_RD) {
463 /* cannot do this, the controller
464 * forces us to send a new START
465 * when we change direction */
466
467 s3c24xx_i2c_stop(i2c, -EINVAL);
468 }
469
470 goto retry_write;
471 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 /* send the new start */
473 s3c24xx_i2c_message_start(i2c, i2c->msg);
474 i2c->state = STATE_START;
475 }
476
477 } else {
478 /* send stop */
479
480 s3c24xx_i2c_stop(i2c, 0);
481 }
482 break;
483
484 case STATE_READ:
Ben Dooks3d0911b2008-10-31 16:10:24 +0000485 /* we have a byte of data in the data register, do
Adam Buchbinder48fc7f72012-09-19 21:48:00 -0400486 * something with it, and then work out whether we are
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 * going to do any more read/write
488 */
489
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 byte = readb(i2c->regs + S3C2410_IICDS);
491 i2c->msg->buf[i2c->msg_ptr++] = byte;
492
Jaemin Yoo857473112013-03-26 04:29:56 +0000493 /* Add actual length to read for smbus block read */
494 if (i2c->msg->flags & I2C_M_RECV_LEN && i2c->msg->len == 1)
495 i2c->msg->len += byte;
Ben Dooks3d0911b2008-10-31 16:10:24 +0000496 prepare_read:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 if (is_msglast(i2c)) {
498 /* last byte of buffer */
499
500 if (is_lastmsg(i2c))
501 s3c24xx_i2c_disable_ack(i2c);
Ben Dooks3d0911b2008-10-31 16:10:24 +0000502
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 } else if (is_msgend(i2c)) {
504 /* ok, we've read the entire buffer, see if there
505 * is anything else we need to do */
506
507 if (is_lastmsg(i2c)) {
508 /* last message, send stop and complete */
509 dev_dbg(i2c->dev, "READ: Send Stop\n");
510
511 s3c24xx_i2c_stop(i2c, 0);
512 } else {
513 /* go to the next transfer */
514 dev_dbg(i2c->dev, "READ: Next Transfer\n");
515
516 i2c->msg_ptr = 0;
517 i2c->msg_idx++;
518 i2c->msg++;
519 }
520 }
521
522 break;
523 }
524
525 /* acknowlegde the IRQ and get back on with the work */
526
527 out_ack:
Ben Dooks3d0911b2008-10-31 16:10:24 +0000528 tmp = readl(i2c->regs + S3C2410_IICCON);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 tmp &= ~S3C2410_IICCON_IRQPEND;
530 writel(tmp, i2c->regs + S3C2410_IICCON);
531 out:
532 return ret;
533}
534
535/* s3c24xx_i2c_irq
536 *
537 * top level IRQ servicing routine
538*/
539
David Howells7d12e782006-10-05 14:55:46 +0100540static irqreturn_t s3c24xx_i2c_irq(int irqno, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541{
542 struct s3c24xx_i2c *i2c = dev_id;
543 unsigned long status;
544 unsigned long tmp;
545
546 status = readl(i2c->regs + S3C2410_IICSTAT);
547
548 if (status & S3C2410_IICSTAT_ARBITR) {
Ben Dooks3d0911b2008-10-31 16:10:24 +0000549 /* deal with arbitration loss */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 dev_err(i2c->dev, "deal with arbitration loss\n");
551 }
552
553 if (i2c->state == STATE_IDLE) {
554 dev_dbg(i2c->dev, "IRQ: error i2c->state == IDLE\n");
555
Ben Dooks3d0911b2008-10-31 16:10:24 +0000556 tmp = readl(i2c->regs + S3C2410_IICCON);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 tmp &= ~S3C2410_IICCON_IRQPEND;
558 writel(tmp, i2c->regs + S3C2410_IICCON);
559 goto out;
560 }
Ben Dooks3d0911b2008-10-31 16:10:24 +0000561
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 /* pretty much this leaves us with the fact that we've
563 * transmitted or received whatever byte we last sent */
564
Huisung Kang19820512011-06-23 21:37:33 +0900565 i2c_s3c_irq_nextbyte(i2c, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566
567 out:
568 return IRQ_HANDLED;
569}
570
571
572/* s3c24xx_i2c_set_master
573 *
574 * get the i2c bus for a master transaction
575*/
576
577static int s3c24xx_i2c_set_master(struct s3c24xx_i2c *i2c)
578{
579 unsigned long iicstat;
580 int timeout = 400;
581
582 while (timeout-- > 0) {
583 iicstat = readl(i2c->regs + S3C2410_IICSTAT);
Ben Dooks3d0911b2008-10-31 16:10:24 +0000584
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 if (!(iicstat & S3C2410_IICSTAT_BUSBUSY))
586 return 0;
587
588 msleep(1);
589 }
590
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 return -ETIMEDOUT;
592}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593
Daniel Kurtzfe724bf2012-11-15 17:43:32 +0530594/* s3c24xx_i2c_wait_idle
595 *
596 * wait for the i2c bus to become idle.
597*/
598
599static void s3c24xx_i2c_wait_idle(struct s3c24xx_i2c *i2c)
600{
601 unsigned long iicstat;
602 ktime_t start, now;
603 unsigned long delay;
Mark Brown31f313d2012-11-21 13:12:11 +0900604 int spins;
Daniel Kurtzfe724bf2012-11-15 17:43:32 +0530605
606 /* ensure the stop has been through the bus */
607
608 dev_dbg(i2c->dev, "waiting for bus idle\n");
609
610 start = now = ktime_get();
611
612 /*
613 * Most of the time, the bus is already idle within a few usec of the
614 * end of a transaction. However, really slow i2c devices can stretch
615 * the clock, delaying STOP generation.
616 *
Mark Brown31f313d2012-11-21 13:12:11 +0900617 * On slower SoCs this typically happens within a very small number of
618 * instructions so busy wait briefly to avoid scheduling overhead.
Daniel Kurtzfe724bf2012-11-15 17:43:32 +0530619 */
Mark Brown31f313d2012-11-21 13:12:11 +0900620 spins = 3;
Daniel Kurtzfe724bf2012-11-15 17:43:32 +0530621 iicstat = readl(i2c->regs + S3C2410_IICSTAT);
Mark Brown31f313d2012-11-21 13:12:11 +0900622 while ((iicstat & S3C2410_IICSTAT_START) && --spins) {
623 cpu_relax();
624 iicstat = readl(i2c->regs + S3C2410_IICSTAT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 }
626
Mark Brown31f313d2012-11-21 13:12:11 +0900627 /*
628 * If we do get an appreciable delay as a compromise between idle
629 * detection latency for the normal, fast case, and system load in the
630 * slow device case, use an exponential back off in the polling loop,
631 * up to 1/10th of the total timeout, then continue to poll at a
632 * constant rate up to the timeout.
633 */
Daniel Kurtzfe724bf2012-11-15 17:43:32 +0530634 delay = 1;
635 while ((iicstat & S3C2410_IICSTAT_START) &&
636 ktime_us_delta(now, start) < S3C2410_IDLE_TIMEOUT) {
637 usleep_range(delay, 2 * delay);
638 if (delay < S3C2410_IDLE_TIMEOUT / 10)
639 delay <<= 1;
640 now = ktime_get();
641 iicstat = readl(i2c->regs + S3C2410_IICSTAT);
642 }
643
644 if (iicstat & S3C2410_IICSTAT_START)
645 dev_warn(i2c->dev, "timeout waiting for bus idle\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646}
647
648/* s3c24xx_i2c_doxfer
649 *
650 * this starts an i2c transfer
651*/
652
Ben Dooks3d0911b2008-10-31 16:10:24 +0000653static int s3c24xx_i2c_doxfer(struct s3c24xx_i2c *i2c,
654 struct i2c_msg *msgs, int num)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655{
Daniel Kurtzfe724bf2012-11-15 17:43:32 +0530656 unsigned long timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 int ret;
658
Ben Dooksbe44f012008-10-31 16:10:22 +0000659 if (i2c->suspended)
Ben Dooks61c7cff2008-07-28 12:04:07 +0100660 return -EIO;
661
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 ret = s3c24xx_i2c_set_master(i2c);
663 if (ret != 0) {
664 dev_err(i2c->dev, "cannot get bus (error %d)\n", ret);
665 ret = -EAGAIN;
666 goto out;
667 }
668
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 i2c->msg = msgs;
670 i2c->msg_num = num;
671 i2c->msg_ptr = 0;
672 i2c->msg_idx = 0;
673 i2c->state = STATE_START;
674
675 s3c24xx_i2c_enable_irq(i2c);
676 s3c24xx_i2c_message_start(i2c, msgs);
Ben Dooks3d0911b2008-10-31 16:10:24 +0000677
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 timeout = wait_event_timeout(i2c->wait, i2c->msg_num == 0, HZ * 5);
679
680 ret = i2c->msg_idx;
681
Ben Dooks3d0911b2008-10-31 16:10:24 +0000682 /* having these next two as dev_err() makes life very
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 * noisy when doing an i2cdetect */
684
685 if (timeout == 0)
686 dev_dbg(i2c->dev, "timeout\n");
687 else if (ret != num)
688 dev_dbg(i2c->dev, "incomplete xfer (%d)\n", ret);
689
Daniel Kurtz0da2e772012-11-15 17:43:31 +0530690 /* For QUIRK_HDMIPHY, bus is already disabled */
691 if (i2c->quirks & QUIRK_HDMIPHY)
692 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693
Daniel Kurtzfe724bf2012-11-15 17:43:32 +0530694 s3c24xx_i2c_wait_idle(i2c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695
696 out:
697 return ret;
698}
699
700/* s3c24xx_i2c_xfer
701 *
702 * first port of call from the i2c bus code when an message needs
Steven Cole44bbe872005-05-03 18:21:25 -0600703 * transferring across the i2c bus.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704*/
705
706static int s3c24xx_i2c_xfer(struct i2c_adapter *adap,
707 struct i2c_msg *msgs, int num)
708{
709 struct s3c24xx_i2c *i2c = (struct s3c24xx_i2c *)adap->algo_data;
710 int retry;
711 int ret;
712
Mark Brownc62c3ca2012-01-21 13:28:47 +0000713 pm_runtime_get_sync(&adap->dev);
Thomas Abrahamd3b64c52012-10-03 08:26:39 +0900714 clk_prepare_enable(i2c->clk);
Arnaud Patard (Rtp)d2360b82010-07-15 15:06:14 +0200715
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 for (retry = 0; retry < adap->retries; retry++) {
717
718 ret = s3c24xx_i2c_doxfer(i2c, msgs, num);
719
Arnaud Patard (Rtp)d2360b82010-07-15 15:06:14 +0200720 if (ret != -EAGAIN) {
Thomas Abrahamd3b64c52012-10-03 08:26:39 +0900721 clk_disable_unprepare(i2c->clk);
Mark Browna86ae9f2012-06-28 14:08:26 +0100722 pm_runtime_put(&adap->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 return ret;
Arnaud Patard (Rtp)d2360b82010-07-15 15:06:14 +0200724 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725
726 dev_dbg(i2c->dev, "Retrying transmission (%d)\n", retry);
727
728 udelay(100);
729 }
730
Thomas Abrahamd3b64c52012-10-03 08:26:39 +0900731 clk_disable_unprepare(i2c->clk);
Mark Browna86ae9f2012-06-28 14:08:26 +0100732 pm_runtime_put(&adap->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 return -EREMOTEIO;
734}
735
736/* declare our i2c functionality */
737static u32 s3c24xx_i2c_func(struct i2c_adapter *adap)
738{
Mark Brown14674e72012-05-30 10:55:34 +0200739 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | I2C_FUNC_NOSTART |
740 I2C_FUNC_PROTOCOL_MANGLING;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741}
742
743/* i2c bus registration info */
744
Jean Delvare8f9082c2006-09-03 22:39:46 +0200745static const struct i2c_algorithm s3c24xx_i2c_algorithm = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 .master_xfer = s3c24xx_i2c_xfer,
747 .functionality = s3c24xx_i2c_func,
748};
749
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750/* s3c24xx_i2c_calcdivisor
751 *
752 * return the divisor settings for a given frequency
753*/
754
755static int s3c24xx_i2c_calcdivisor(unsigned long clkin, unsigned int wanted,
756 unsigned int *div1, unsigned int *divs)
757{
758 unsigned int calc_divs = clkin / wanted;
759 unsigned int calc_div1;
760
761 if (calc_divs > (16*16))
762 calc_div1 = 512;
763 else
764 calc_div1 = 16;
765
766 calc_divs += calc_div1-1;
767 calc_divs /= calc_div1;
768
769 if (calc_divs == 0)
770 calc_divs = 1;
771 if (calc_divs > 17)
772 calc_divs = 17;
773
774 *divs = calc_divs;
775 *div1 = calc_div1;
776
777 return clkin / (calc_divs * calc_div1);
778}
779
Ben Dooks61c7cff2008-07-28 12:04:07 +0100780/* s3c24xx_i2c_clockrate
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 *
782 * work out a divisor for the user requested frequency setting,
783 * either by the requested frequency, or scanning the acceptable
784 * range of frequencies until something is found
785*/
786
Ben Dooks61c7cff2008-07-28 12:04:07 +0100787static int s3c24xx_i2c_clockrate(struct s3c24xx_i2c *i2c, unsigned int *got)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788{
Thomas Abraham4fd81eb2011-09-13 09:46:04 +0530789 struct s3c2410_platform_i2c *pdata = i2c->pdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 unsigned long clkin = clk_get_rate(i2c->clk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 unsigned int divs, div1;
Daniel Silverstonec564e6a2009-03-13 13:53:46 +0000792 unsigned long target_frequency;
Ben Dooks61c7cff2008-07-28 12:04:07 +0100793 u32 iiccon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 int freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795
Ben Dooks61c7cff2008-07-28 12:04:07 +0100796 i2c->clkrate = clkin;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 clkin /= 1000; /* clkin now in KHz */
Ben Dooks3d0911b2008-10-31 16:10:24 +0000798
Daniel Silverstonec564e6a2009-03-13 13:53:46 +0000799 dev_dbg(i2c->dev, "pdata desired frequency %lu\n", pdata->frequency);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800
Daniel Silverstonec564e6a2009-03-13 13:53:46 +0000801 target_frequency = pdata->frequency ? pdata->frequency : 100000;
802
803 target_frequency /= 1000; /* Target frequency now in KHz */
804
805 freq = s3c24xx_i2c_calcdivisor(clkin, target_frequency, &div1, &divs);
806
807 if (freq > target_frequency) {
808 dev_err(i2c->dev,
809 "Unable to achieve desired frequency %luKHz." \
810 " Lowest achievable %dKHz\n", target_frequency, freq);
811 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 }
813
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 *got = freq;
Ben Dooks61c7cff2008-07-28 12:04:07 +0100815
816 iiccon = readl(i2c->regs + S3C2410_IICCON);
817 iiccon &= ~(S3C2410_IICCON_SCALEMASK | S3C2410_IICCON_TXDIV_512);
818 iiccon |= (divs-1);
819
820 if (div1 == 512)
821 iiccon |= S3C2410_IICCON_TXDIV_512;
822
823 writel(iiccon, i2c->regs + S3C2410_IICCON);
824
Karol Lewandowski27452492012-04-23 18:24:00 +0200825 if (i2c->quirks & QUIRK_S3C2440) {
Ben Dooksa192f712009-03-27 10:52:13 +0000826 unsigned long sda_delay;
827
828 if (pdata->sda_delay) {
MyungJoo Ham70313072010-09-30 15:54:46 +0200829 sda_delay = clkin * pdata->sda_delay;
830 sda_delay = DIV_ROUND_UP(sda_delay, 1000000);
Ben Dooksa192f712009-03-27 10:52:13 +0000831 sda_delay = DIV_ROUND_UP(sda_delay, 5);
832 if (sda_delay > 3)
833 sda_delay = 3;
834 sda_delay |= S3C2410_IICLC_FILTER_ON;
835 } else
836 sda_delay = 0;
837
838 dev_dbg(i2c->dev, "IICLC=%08lx\n", sda_delay);
839 writel(sda_delay, i2c->regs + S3C2440_IICLC);
840 }
841
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 return 0;
843}
844
Ben Dooks61c7cff2008-07-28 12:04:07 +0100845#ifdef CONFIG_CPU_FREQ
846
847#define freq_to_i2c(_n) container_of(_n, struct s3c24xx_i2c, freq_transition)
848
849static int s3c24xx_i2c_cpufreq_transition(struct notifier_block *nb,
850 unsigned long val, void *data)
851{
852 struct s3c24xx_i2c *i2c = freq_to_i2c(nb);
Ben Dooks61c7cff2008-07-28 12:04:07 +0100853 unsigned int got;
854 int delta_f;
855 int ret;
856
857 delta_f = clk_get_rate(i2c->clk) - i2c->clkrate;
858
859 /* if we're post-change and the input clock has slowed down
860 * or at pre-change and the clock is about to speed up, then
861 * adjust our clock rate. <0 is slow, >0 speedup.
862 */
863
864 if ((val == CPUFREQ_POSTCHANGE && delta_f < 0) ||
865 (val == CPUFREQ_PRECHANGE && delta_f > 0)) {
Daniel Kurtz9bcd04b2012-11-15 17:43:30 +0530866 i2c_lock_adapter(&i2c->adap);
Ben Dooks61c7cff2008-07-28 12:04:07 +0100867 ret = s3c24xx_i2c_clockrate(i2c, &got);
Daniel Kurtz9bcd04b2012-11-15 17:43:30 +0530868 i2c_unlock_adapter(&i2c->adap);
Ben Dooks61c7cff2008-07-28 12:04:07 +0100869
870 if (ret < 0)
871 dev_err(i2c->dev, "cannot find frequency\n");
872 else
873 dev_info(i2c->dev, "setting freq %d\n", got);
874 }
875
876 return 0;
877}
878
879static inline int s3c24xx_i2c_register_cpufreq(struct s3c24xx_i2c *i2c)
880{
881 i2c->freq_transition.notifier_call = s3c24xx_i2c_cpufreq_transition;
882
883 return cpufreq_register_notifier(&i2c->freq_transition,
884 CPUFREQ_TRANSITION_NOTIFIER);
885}
886
887static inline void s3c24xx_i2c_deregister_cpufreq(struct s3c24xx_i2c *i2c)
888{
889 cpufreq_unregister_notifier(&i2c->freq_transition,
890 CPUFREQ_TRANSITION_NOTIFIER);
891}
892
893#else
894static inline int s3c24xx_i2c_register_cpufreq(struct s3c24xx_i2c *i2c)
895{
896 return 0;
897}
898
899static inline void s3c24xx_i2c_deregister_cpufreq(struct s3c24xx_i2c *i2c)
900{
901}
902#endif
903
Thomas Abraham5a5f5082011-09-13 09:46:05 +0530904#ifdef CONFIG_OF
905static int s3c24xx_i2c_parse_dt_gpio(struct s3c24xx_i2c *i2c)
906{
907 int idx, gpio, ret;
908
Karol Lewandowskiec39ef82012-04-23 18:24:01 +0200909 if (i2c->quirks & QUIRK_NO_GPIO)
910 return 0;
911
Thomas Abraham5a5f5082011-09-13 09:46:05 +0530912 for (idx = 0; idx < 2; idx++) {
913 gpio = of_get_gpio(i2c->dev->of_node, idx);
914 if (!gpio_is_valid(gpio)) {
915 dev_err(i2c->dev, "invalid gpio[%d]: %d\n", idx, gpio);
916 goto free_gpio;
917 }
Abhilash Kesavan963f2072012-11-19 15:48:46 +0530918 i2c->gpios[idx] = gpio;
Thomas Abraham5a5f5082011-09-13 09:46:05 +0530919
920 ret = gpio_request(gpio, "i2c-bus");
921 if (ret) {
922 dev_err(i2c->dev, "gpio [%d] request failed\n", gpio);
923 goto free_gpio;
924 }
925 }
926 return 0;
927
928free_gpio:
929 while (--idx >= 0)
930 gpio_free(i2c->gpios[idx]);
931 return -EINVAL;
932}
933
934static void s3c24xx_i2c_dt_gpio_free(struct s3c24xx_i2c *i2c)
935{
936 unsigned int idx;
Karol Lewandowskiec39ef82012-04-23 18:24:01 +0200937
938 if (i2c->quirks & QUIRK_NO_GPIO)
939 return;
940
Thomas Abraham5a5f5082011-09-13 09:46:05 +0530941 for (idx = 0; idx < 2; idx++)
942 gpio_free(i2c->gpios[idx]);
943}
944#else
945static int s3c24xx_i2c_parse_dt_gpio(struct s3c24xx_i2c *i2c)
946{
Tushar Behera8ebe6612011-12-09 15:33:55 +0530947 return 0;
Thomas Abraham5a5f5082011-09-13 09:46:05 +0530948}
949
950static void s3c24xx_i2c_dt_gpio_free(struct s3c24xx_i2c *i2c)
951{
952}
953#endif
954
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955/* s3c24xx_i2c_init
956 *
Ben Dooks3d0911b2008-10-31 16:10:24 +0000957 * initialise the controller, set the IO lines and frequency
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958*/
959
960static int s3c24xx_i2c_init(struct s3c24xx_i2c *i2c)
961{
962 unsigned long iicon = S3C2410_IICCON_IRQEN | S3C2410_IICCON_ACKEN;
963 struct s3c2410_platform_i2c *pdata;
964 unsigned int freq;
965
966 /* get the plafrom data */
967
Thomas Abraham4fd81eb2011-09-13 09:46:04 +0530968 pdata = i2c->pdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 /* write slave address */
Ben Dooks3d0911b2008-10-31 16:10:24 +0000971
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 writeb(pdata->slave_addr, i2c->regs + S3C2410_IICADD);
973
974 dev_info(i2c->dev, "slave address 0x%02x\n", pdata->slave_addr);
975
Ben Dooks61c7cff2008-07-28 12:04:07 +0100976 writel(iicon, i2c->regs + S3C2410_IICCON);
977
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 /* we need to work out the divisors for the clock... */
979
Ben Dooks61c7cff2008-07-28 12:04:07 +0100980 if (s3c24xx_i2c_clockrate(i2c, &freq) != 0) {
981 writel(0, i2c->regs + S3C2410_IICCON);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982 dev_err(i2c->dev, "cannot meet bus frequency required\n");
983 return -EINVAL;
984 }
985
986 /* todo - check that the i2c lines aren't being dragged anywhere */
987
988 dev_info(i2c->dev, "bus frequency set to %d KHz\n", freq);
989 dev_dbg(i2c->dev, "S3C2410_IICCON=0x%02lx\n", iicon);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 return 0;
992}
993
Thomas Abraham5a5f5082011-09-13 09:46:05 +0530994#ifdef CONFIG_OF
995/* s3c24xx_i2c_parse_dt
996 *
997 * Parse the device tree node and retreive the platform data.
998*/
999
1000static void
1001s3c24xx_i2c_parse_dt(struct device_node *np, struct s3c24xx_i2c *i2c)
1002{
1003 struct s3c2410_platform_i2c *pdata = i2c->pdata;
1004
1005 if (!np)
1006 return;
1007
1008 pdata->bus_num = -1; /* i2c bus number is dynamically assigned */
1009 of_property_read_u32(np, "samsung,i2c-sda-delay", &pdata->sda_delay);
1010 of_property_read_u32(np, "samsung,i2c-slave-addr", &pdata->slave_addr);
1011 of_property_read_u32(np, "samsung,i2c-max-bus-freq",
1012 (u32 *)&pdata->frequency);
1013}
1014#else
1015static void
1016s3c24xx_i2c_parse_dt(struct device_node *np, struct s3c24xx_i2c *i2c)
1017{
1018 return;
1019}
1020#endif
1021
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022/* s3c24xx_i2c_probe
1023 *
1024 * called by the bus driver when a suitable device is found
1025*/
1026
Russell King3ae5eae2005-11-09 22:32:44 +00001027static int s3c24xx_i2c_probe(struct platform_device *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028{
Ben Dooks692acbd2008-10-31 16:10:28 +00001029 struct s3c24xx_i2c *i2c;
Thomas Abraham4fd81eb2011-09-13 09:46:04 +05301030 struct s3c2410_platform_i2c *pdata = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 struct resource *res;
1032 int ret;
1033
Thomas Abraham5a5f5082011-09-13 09:46:05 +05301034 if (!pdev->dev.of_node) {
Jingoo Han6d4028c2013-07-30 16:59:33 +09001035 pdata = dev_get_platdata(&pdev->dev);
Thomas Abraham5a5f5082011-09-13 09:46:05 +05301036 if (!pdata) {
1037 dev_err(&pdev->dev, "no platform data\n");
1038 return -EINVAL;
1039 }
Ben Dooks6a039ca2008-10-31 16:10:27 +00001040 }
Ben Dooks399dee22008-07-28 12:04:06 +01001041
Mark Brown4ea15572012-01-21 13:28:46 +00001042 i2c = devm_kzalloc(&pdev->dev, sizeof(struct s3c24xx_i2c), GFP_KERNEL);
Ben Dooks692acbd2008-10-31 16:10:28 +00001043 if (!i2c) {
1044 dev_err(&pdev->dev, "no memory for state\n");
1045 return -ENOMEM;
1046 }
1047
Thomas Abraham4fd81eb2011-09-13 09:46:04 +05301048 i2c->pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
1049 if (!i2c->pdata) {
Tushar Behera669da302013-01-24 15:41:06 +05301050 dev_err(&pdev->dev, "no memory for platform data\n");
1051 return -ENOMEM;
Thomas Abraham4fd81eb2011-09-13 09:46:04 +05301052 }
1053
Karol Lewandowski27452492012-04-23 18:24:00 +02001054 i2c->quirks = s3c24xx_get_device_quirks(pdev);
Thomas Abraham4fd81eb2011-09-13 09:46:04 +05301055 if (pdata)
1056 memcpy(i2c->pdata, pdata, sizeof(*pdata));
Thomas Abraham5a5f5082011-09-13 09:46:05 +05301057 else
1058 s3c24xx_i2c_parse_dt(pdev->dev.of_node, i2c);
Thomas Abraham4fd81eb2011-09-13 09:46:04 +05301059
Ben Dooks692acbd2008-10-31 16:10:28 +00001060 strlcpy(i2c->adap.name, "s3c2410-i2c", sizeof(i2c->adap.name));
1061 i2c->adap.owner = THIS_MODULE;
1062 i2c->adap.algo = &s3c24xx_i2c_algorithm;
1063 i2c->adap.retries = 2;
1064 i2c->adap.class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
1065 i2c->tx_setup = 50;
1066
Ben Dooks692acbd2008-10-31 16:10:28 +00001067 init_waitqueue_head(&i2c->wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068
1069 /* find the clock and enable it */
1070
Russell King3ae5eae2005-11-09 22:32:44 +00001071 i2c->dev = &pdev->dev;
Tushar Behera2b255b92013-01-24 15:41:07 +05301072 i2c->clk = devm_clk_get(&pdev->dev, "i2c");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 if (IS_ERR(i2c->clk)) {
Russell King3ae5eae2005-11-09 22:32:44 +00001074 dev_err(&pdev->dev, "cannot get clock\n");
Tushar Behera669da302013-01-24 15:41:06 +05301075 return -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076 }
1077
Russell King3ae5eae2005-11-09 22:32:44 +00001078 dev_dbg(&pdev->dev, "clock source %p\n", i2c->clk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080
1081 /* map the registers */
1082
1083 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
Thierry Reding84dbf802013-01-21 11:09:03 +01001084 i2c->regs = devm_ioremap_resource(&pdev->dev, res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085
Linus Torvalds52caa592013-02-26 09:41:53 -08001086 if (IS_ERR(i2c->regs))
1087 return PTR_ERR(i2c->regs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088
Mark Browna72ad452012-11-05 09:33:39 +01001089 dev_dbg(&pdev->dev, "registers %p (%p)\n",
1090 i2c->regs, res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091
1092 /* setup info block for the i2c core */
1093
1094 i2c->adap.algo_data = i2c;
Russell King3ae5eae2005-11-09 22:32:44 +00001095 i2c->adap.dev.parent = &pdev->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096
Tomasz Figa2693ac62012-11-13 11:33:40 +01001097 i2c->pctrl = devm_pinctrl_get_select_default(i2c->dev);
1098
Abhilash Kesavan658122f2012-11-19 15:47:17 +05301099 /* inititalise the i2c gpio lines */
1100
1101 if (i2c->pdata->cfg_gpio) {
1102 i2c->pdata->cfg_gpio(to_platform_device(i2c->dev));
1103 } else if (IS_ERR(i2c->pctrl) && s3c24xx_i2c_parse_dt_gpio(i2c)) {
Tushar Beherad16933b2013-01-24 15:41:08 +05301104 return -EINVAL;
Abhilash Kesavan658122f2012-11-19 15:47:17 +05301105 }
1106
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 /* initialise the i2c controller */
1108
Tushar Beherad16933b2013-01-24 15:41:08 +05301109 clk_prepare_enable(i2c->clk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110 ret = s3c24xx_i2c_init(i2c);
Tushar Beherad16933b2013-01-24 15:41:08 +05301111 clk_disable_unprepare(i2c->clk);
1112 if (ret != 0) {
1113 dev_err(&pdev->dev, "I2C controller init failed\n");
1114 return ret;
1115 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 /* find the IRQ for this unit (note, this relies on the init call to
Ben Dooks3d0911b2008-10-31 16:10:24 +00001117 * ensure no current IRQs pending
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 */
1119
Ben Dookse0d1ec92008-10-31 16:10:30 +00001120 i2c->irq = ret = platform_get_irq(pdev, 0);
1121 if (ret <= 0) {
Russell King3ae5eae2005-11-09 22:32:44 +00001122 dev_err(&pdev->dev, "cannot find IRQ\n");
Tushar Beherad16933b2013-01-24 15:41:08 +05301123 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124 }
1125
Tushar Behera2b255b92013-01-24 15:41:07 +05301126 ret = devm_request_irq(&pdev->dev, i2c->irq, s3c24xx_i2c_irq, 0,
1127 dev_name(&pdev->dev), i2c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128
1129 if (ret != 0) {
Ben Dookse0d1ec92008-10-31 16:10:30 +00001130 dev_err(&pdev->dev, "cannot claim IRQ %d\n", i2c->irq);
Tushar Beherad16933b2013-01-24 15:41:08 +05301131 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 }
1133
Ben Dooks61c7cff2008-07-28 12:04:07 +01001134 ret = s3c24xx_i2c_register_cpufreq(i2c);
1135 if (ret < 0) {
1136 dev_err(&pdev->dev, "failed to register cpufreq notifier\n");
Tushar Beherad16933b2013-01-24 15:41:08 +05301137 return ret;
Ben Dooks61c7cff2008-07-28 12:04:07 +01001138 }
1139
Ben Dooks399dee22008-07-28 12:04:06 +01001140 /* Note, previous versions of the driver used i2c_add_adapter()
1141 * to add the bus at any number. We now pass the bus number via
1142 * the platform data, so if unset it will now default to always
1143 * being bus 0.
1144 */
1145
Thomas Abraham4fd81eb2011-09-13 09:46:04 +05301146 i2c->adap.nr = i2c->pdata->bus_num;
Thomas Abraham5a5f5082011-09-13 09:46:05 +05301147 i2c->adap.dev.of_node = pdev->dev.of_node;
Ben Dooks399dee22008-07-28 12:04:06 +01001148
1149 ret = i2c_add_numbered_adapter(&i2c->adap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 if (ret < 0) {
Russell King3ae5eae2005-11-09 22:32:44 +00001151 dev_err(&pdev->dev, "failed to add bus to i2c core\n");
Tushar Beheradc6fea42013-01-24 15:41:09 +05301152 s3c24xx_i2c_deregister_cpufreq(i2c);
1153 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 }
1155
Russell King3ae5eae2005-11-09 22:32:44 +00001156 platform_set_drvdata(pdev, i2c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157
Mark Brownc62c3ca2012-01-21 13:28:47 +00001158 pm_runtime_enable(&pdev->dev);
1159 pm_runtime_enable(&i2c->adap.dev);
1160
Jean Delvare22e965c2009-01-07 14:29:16 +01001161 dev_info(&pdev->dev, "%s: S3C I2C adapter\n", dev_name(&i2c->adap.dev));
Ben Dooks5b687902007-05-01 23:26:35 +02001162 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163}
1164
1165/* s3c24xx_i2c_remove
1166 *
1167 * called when device is removed from the bus
1168*/
1169
Russell King3ae5eae2005-11-09 22:32:44 +00001170static int s3c24xx_i2c_remove(struct platform_device *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171{
Russell King3ae5eae2005-11-09 22:32:44 +00001172 struct s3c24xx_i2c *i2c = platform_get_drvdata(pdev);
Ben Dooks5b687902007-05-01 23:26:35 +02001173
Mark Brownc62c3ca2012-01-21 13:28:47 +00001174 pm_runtime_disable(&i2c->adap.dev);
1175 pm_runtime_disable(&pdev->dev);
1176
Ben Dooks61c7cff2008-07-28 12:04:07 +01001177 s3c24xx_i2c_deregister_cpufreq(i2c);
1178
Ben Dooks5b687902007-05-01 23:26:35 +02001179 i2c_del_adapter(&i2c->adap);
Ben Dooks5b687902007-05-01 23:26:35 +02001180
Tomasz Figa2693ac62012-11-13 11:33:40 +01001181 if (pdev->dev.of_node && IS_ERR(i2c->pctrl))
1182 s3c24xx_i2c_dt_gpio_free(i2c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183
1184 return 0;
1185}
1186
Mark Brown2935e0e2012-11-05 09:33:38 +01001187#ifdef CONFIG_PM_SLEEP
Magnus Damm6a6c61892009-07-08 13:22:47 +02001188static int s3c24xx_i2c_suspend_noirq(struct device *dev)
Ben Dooksbe44f012008-10-31 16:10:22 +00001189{
Magnus Damm6a6c61892009-07-08 13:22:47 +02001190 struct platform_device *pdev = to_platform_device(dev);
1191 struct s3c24xx_i2c *i2c = platform_get_drvdata(pdev);
1192
Ben Dooksbe44f012008-10-31 16:10:22 +00001193 i2c->suspended = 1;
Magnus Damm6a6c61892009-07-08 13:22:47 +02001194
Ben Dooksbe44f012008-10-31 16:10:22 +00001195 return 0;
1196}
1197
Magnus Damm6a6c61892009-07-08 13:22:47 +02001198static int s3c24xx_i2c_resume(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199{
Magnus Damm6a6c61892009-07-08 13:22:47 +02001200 struct platform_device *pdev = to_platform_device(dev);
1201 struct s3c24xx_i2c *i2c = platform_get_drvdata(pdev);
Russell King9480e302005-10-28 09:52:56 -07001202
Ben Dooksbe44f012008-10-31 16:10:22 +00001203 i2c->suspended = 0;
Thomas Abrahamd3b64c52012-10-03 08:26:39 +09001204 clk_prepare_enable(i2c->clk);
Ben Dooksbe44f012008-10-31 16:10:22 +00001205 s3c24xx_i2c_init(i2c);
Thomas Abrahamd3b64c52012-10-03 08:26:39 +09001206 clk_disable_unprepare(i2c->clk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207
1208 return 0;
1209}
Mark Brown2935e0e2012-11-05 09:33:38 +01001210#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211
Mark Brown2935e0e2012-11-05 09:33:38 +01001212#ifdef CONFIG_PM
Alexey Dobriyan47145212009-12-14 18:00:08 -08001213static const struct dev_pm_ops s3c24xx_i2c_dev_pm_ops = {
Mark Brown2935e0e2012-11-05 09:33:38 +01001214#ifdef CONFIG_PM_SLEEP
Magnus Damm6a6c61892009-07-08 13:22:47 +02001215 .suspend_noirq = s3c24xx_i2c_suspend_noirq,
1216 .resume = s3c24xx_i2c_resume,
Mark Brown2935e0e2012-11-05 09:33:38 +01001217#endif
Magnus Damm6a6c61892009-07-08 13:22:47 +02001218};
1219
1220#define S3C24XX_DEV_PM_OPS (&s3c24xx_i2c_dev_pm_ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221#else
Magnus Damm6a6c61892009-07-08 13:22:47 +02001222#define S3C24XX_DEV_PM_OPS NULL
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223#endif
1224
1225/* device driver for platform bus bits */
1226
Ben Dooks7d85ccd2009-06-12 10:45:29 +01001227static struct platform_driver s3c24xx_i2c_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 .probe = s3c24xx_i2c_probe,
1229 .remove = s3c24xx_i2c_remove,
Ben Dooks7d85ccd2009-06-12 10:45:29 +01001230 .id_table = s3c24xx_driver_ids,
Russell King3ae5eae2005-11-09 22:32:44 +00001231 .driver = {
1232 .owner = THIS_MODULE,
Ben Dooks7d85ccd2009-06-12 10:45:29 +01001233 .name = "s3c-i2c",
Magnus Damm6a6c61892009-07-08 13:22:47 +02001234 .pm = S3C24XX_DEV_PM_OPS,
Karol Lewandowski9df7ead2012-03-21 20:11:51 +01001235 .of_match_table = of_match_ptr(s3c24xx_i2c_match),
Russell King3ae5eae2005-11-09 22:32:44 +00001236 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237};
1238
1239static int __init i2c_adap_s3c_init(void)
1240{
Ben Dooks7d85ccd2009-06-12 10:45:29 +01001241 return platform_driver_register(&s3c24xx_i2c_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242}
Mark Brown18dc83a2009-02-26 16:29:22 +00001243subsys_initcall(i2c_adap_s3c_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244
1245static void __exit i2c_adap_s3c_exit(void)
1246{
Ben Dooks7d85ccd2009-06-12 10:45:29 +01001247 platform_driver_unregister(&s3c24xx_i2c_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249module_exit(i2c_adap_s3c_exit);
1250
1251MODULE_DESCRIPTION("S3C24XX I2C Bus driver");
1252MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>");
1253MODULE_LICENSE("GPL");