2019-05-27 00:55:06 -06:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2006-08-13 15:44:09 -06:00
|
|
|
/*
|
|
|
|
* TI OMAP I2C master mode driver
|
|
|
|
*
|
|
|
|
* Copyright (C) 2003 MontaVista Software, Inc.
|
|
|
|
* Copyright (C) 2005 Nokia Corporation
|
2008-11-21 14:39:47 -07:00
|
|
|
* Copyright (C) 2004 - 2007 Texas Instruments.
|
2006-08-13 15:44:09 -06:00
|
|
|
*
|
2008-11-21 14:39:47 -07:00
|
|
|
* Originally written by MontaVista Software, Inc.
|
|
|
|
* Additional contributions by:
|
|
|
|
* Tony Lindgren <tony@atomide.com>
|
|
|
|
* Imre Deak <imre.deak@nokia.com>
|
|
|
|
* Juha Yrjölä <juha.yrjola@solidboot.com>
|
|
|
|
* Syed Khasim <x0khasim@ti.com>
|
|
|
|
* Nishant Menon <nm@ti.com>
|
2006-08-13 15:44:09 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/i2c.h>
|
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/completion.h>
|
|
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/clk.h>
|
2008-11-21 14:39:47 -07:00
|
|
|
#include <linux/io.h>
|
2011-12-22 07:56:36 -07:00
|
|
|
#include <linux/of.h>
|
|
|
|
#include <linux/of_device.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2018-04-19 14:00:10 -06:00
|
|
|
#include <linux/platform_data/i2c-omap.h>
|
2010-09-28 09:32:58 -06:00
|
|
|
#include <linux/pm_runtime.h>
|
2015-05-06 07:07:04 -06:00
|
|
|
#include <linux/pinctrl/consumer.h>
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2008-11-21 14:39:55 -07:00
|
|
|
/* I2C controller revisions */
|
2011-05-30 08:43:07 -06:00
|
|
|
#define OMAP_I2C_OMAP1_REV_2 0x20
|
2008-11-21 14:39:55 -07:00
|
|
|
|
|
|
|
/* I2C controller revisions present on specific hardware */
|
2012-11-05 05:23:36 -07:00
|
|
|
#define OMAP_I2C_REV_ON_2430 0x00000036
|
|
|
|
#define OMAP_I2C_REV_ON_3430_3530 0x0000003C
|
|
|
|
#define OMAP_I2C_REV_ON_3630 0x00000040
|
|
|
|
#define OMAP_I2C_REV_ON_4430_PLUS 0x50400002
|
2008-11-21 14:39:55 -07:00
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
/* timeout waiting for the controller to respond */
|
|
|
|
#define OMAP_I2C_TIMEOUT (msecs_to_jiffies(1000))
|
|
|
|
|
2012-09-12 04:58:15 -06:00
|
|
|
/* timeout for pm runtime autosuspend */
|
|
|
|
#define OMAP_I2C_PM_TIMEOUT 1000 /* ms */
|
|
|
|
|
2014-11-22 12:47:12 -07:00
|
|
|
/* timeout for making decision on bus free status */
|
|
|
|
#define OMAP_I2C_BUS_FREE_TIMEOUT (msecs_to_jiffies(10))
|
|
|
|
|
2008-11-21 14:39:55 -07:00
|
|
|
/* For OMAP3 I2C_IV has changed to I2C_WE (wakeup enable) */
|
2010-05-11 12:35:04 -06:00
|
|
|
enum {
|
|
|
|
OMAP_I2C_REV_REG = 0,
|
|
|
|
OMAP_I2C_IE_REG,
|
|
|
|
OMAP_I2C_STAT_REG,
|
|
|
|
OMAP_I2C_IV_REG,
|
|
|
|
OMAP_I2C_WE_REG,
|
|
|
|
OMAP_I2C_SYSS_REG,
|
|
|
|
OMAP_I2C_BUF_REG,
|
|
|
|
OMAP_I2C_CNT_REG,
|
|
|
|
OMAP_I2C_DATA_REG,
|
|
|
|
OMAP_I2C_SYSC_REG,
|
|
|
|
OMAP_I2C_CON_REG,
|
|
|
|
OMAP_I2C_OA_REG,
|
|
|
|
OMAP_I2C_SA_REG,
|
|
|
|
OMAP_I2C_PSC_REG,
|
|
|
|
OMAP_I2C_SCLL_REG,
|
|
|
|
OMAP_I2C_SCLH_REG,
|
|
|
|
OMAP_I2C_SYSTEST_REG,
|
|
|
|
OMAP_I2C_BUFSTAT_REG,
|
2011-05-30 08:43:04 -06:00
|
|
|
/* only on OMAP4430 */
|
|
|
|
OMAP_I2C_IP_V2_REVNB_LO,
|
|
|
|
OMAP_I2C_IP_V2_REVNB_HI,
|
|
|
|
OMAP_I2C_IP_V2_IRQSTATUS_RAW,
|
|
|
|
OMAP_I2C_IP_V2_IRQENABLE_SET,
|
|
|
|
OMAP_I2C_IP_V2_IRQENABLE_CLR,
|
2010-05-11 12:35:04 -06:00
|
|
|
};
|
2006-08-13 15:44:09 -06:00
|
|
|
|
|
|
|
/* I2C Interrupt Enable Register (OMAP_I2C_IE): */
|
2008-11-21 14:39:46 -07:00
|
|
|
#define OMAP_I2C_IE_XDR (1 << 14) /* TX Buffer drain int enable */
|
|
|
|
#define OMAP_I2C_IE_RDR (1 << 13) /* RX Buffer drain int enable */
|
2006-08-13 15:44:09 -06:00
|
|
|
#define OMAP_I2C_IE_XRDY (1 << 4) /* TX data ready int enable */
|
|
|
|
#define OMAP_I2C_IE_RRDY (1 << 3) /* RX data ready int enable */
|
|
|
|
#define OMAP_I2C_IE_ARDY (1 << 2) /* Access ready int enable */
|
|
|
|
#define OMAP_I2C_IE_NACK (1 << 1) /* No ack interrupt enable */
|
|
|
|
#define OMAP_I2C_IE_AL (1 << 0) /* Arbitration lost int ena */
|
|
|
|
|
|
|
|
/* I2C Status Register (OMAP_I2C_STAT): */
|
2008-11-21 14:39:46 -07:00
|
|
|
#define OMAP_I2C_STAT_XDR (1 << 14) /* TX Buffer draining */
|
|
|
|
#define OMAP_I2C_STAT_RDR (1 << 13) /* RX Buffer draining */
|
2006-08-13 15:44:09 -06:00
|
|
|
#define OMAP_I2C_STAT_BB (1 << 12) /* Bus busy */
|
|
|
|
#define OMAP_I2C_STAT_ROVR (1 << 11) /* Receive overrun */
|
|
|
|
#define OMAP_I2C_STAT_XUDF (1 << 10) /* Transmit underflow */
|
|
|
|
#define OMAP_I2C_STAT_AAS (1 << 9) /* Address as slave */
|
2014-11-22 12:47:11 -07:00
|
|
|
#define OMAP_I2C_STAT_BF (1 << 8) /* Bus Free */
|
2006-08-13 15:44:09 -06:00
|
|
|
#define OMAP_I2C_STAT_XRDY (1 << 4) /* Transmit data ready */
|
|
|
|
#define OMAP_I2C_STAT_RRDY (1 << 3) /* Receive data ready */
|
|
|
|
#define OMAP_I2C_STAT_ARDY (1 << 2) /* Register access ready */
|
|
|
|
#define OMAP_I2C_STAT_NACK (1 << 1) /* No ack interrupt enable */
|
|
|
|
#define OMAP_I2C_STAT_AL (1 << 0) /* Arbitration lost int ena */
|
|
|
|
|
2008-11-21 14:39:55 -07:00
|
|
|
/* I2C WE wakeup enable register */
|
|
|
|
#define OMAP_I2C_WE_XDR_WE (1 << 14) /* TX drain wakup */
|
|
|
|
#define OMAP_I2C_WE_RDR_WE (1 << 13) /* RX drain wakeup */
|
|
|
|
#define OMAP_I2C_WE_AAS_WE (1 << 9) /* Address as slave wakeup*/
|
|
|
|
#define OMAP_I2C_WE_BF_WE (1 << 8) /* Bus free wakeup */
|
|
|
|
#define OMAP_I2C_WE_STC_WE (1 << 6) /* Start condition wakeup */
|
|
|
|
#define OMAP_I2C_WE_GC_WE (1 << 5) /* General call wakeup */
|
|
|
|
#define OMAP_I2C_WE_DRDY_WE (1 << 3) /* TX/RX data ready wakeup */
|
|
|
|
#define OMAP_I2C_WE_ARDY_WE (1 << 2) /* Reg access ready wakeup */
|
|
|
|
#define OMAP_I2C_WE_NACK_WE (1 << 1) /* No acknowledgment wakeup */
|
|
|
|
#define OMAP_I2C_WE_AL_WE (1 << 0) /* Arbitration lost wakeup */
|
|
|
|
|
|
|
|
#define OMAP_I2C_WE_ALL (OMAP_I2C_WE_XDR_WE | OMAP_I2C_WE_RDR_WE | \
|
|
|
|
OMAP_I2C_WE_AAS_WE | OMAP_I2C_WE_BF_WE | \
|
|
|
|
OMAP_I2C_WE_STC_WE | OMAP_I2C_WE_GC_WE | \
|
|
|
|
OMAP_I2C_WE_DRDY_WE | OMAP_I2C_WE_ARDY_WE | \
|
|
|
|
OMAP_I2C_WE_NACK_WE | OMAP_I2C_WE_AL_WE)
|
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
/* I2C Buffer Configuration Register (OMAP_I2C_BUF): */
|
|
|
|
#define OMAP_I2C_BUF_RDMA_EN (1 << 15) /* RX DMA channel enable */
|
2008-11-21 14:39:46 -07:00
|
|
|
#define OMAP_I2C_BUF_RXFIF_CLR (1 << 14) /* RX FIFO Clear */
|
2006-08-13 15:44:09 -06:00
|
|
|
#define OMAP_I2C_BUF_XDMA_EN (1 << 7) /* TX DMA channel enable */
|
2008-11-21 14:39:46 -07:00
|
|
|
#define OMAP_I2C_BUF_TXFIF_CLR (1 << 6) /* TX FIFO Clear */
|
2006-08-13 15:44:09 -06:00
|
|
|
|
|
|
|
/* I2C Configuration Register (OMAP_I2C_CON): */
|
|
|
|
#define OMAP_I2C_CON_EN (1 << 15) /* I2C module enable */
|
|
|
|
#define OMAP_I2C_CON_BE (1 << 14) /* Big endian mode */
|
2008-11-21 14:39:46 -07:00
|
|
|
#define OMAP_I2C_CON_OPMODE_HS (1 << 12) /* High Speed support */
|
2006-08-13 15:44:09 -06:00
|
|
|
#define OMAP_I2C_CON_STB (1 << 11) /* Start byte mode (master) */
|
|
|
|
#define OMAP_I2C_CON_MST (1 << 10) /* Master/slave mode */
|
|
|
|
#define OMAP_I2C_CON_TRX (1 << 9) /* TX/RX mode (master only) */
|
|
|
|
#define OMAP_I2C_CON_XA (1 << 8) /* Expand address */
|
|
|
|
#define OMAP_I2C_CON_RM (1 << 2) /* Repeat mode (master only) */
|
|
|
|
#define OMAP_I2C_CON_STP (1 << 1) /* Stop cond (master only) */
|
|
|
|
#define OMAP_I2C_CON_STT (1 << 0) /* Start condition (master) */
|
|
|
|
|
2008-11-21 14:39:45 -07:00
|
|
|
/* I2C SCL time value when Master */
|
|
|
|
#define OMAP_I2C_SCLL_HSSCLL 8
|
|
|
|
#define OMAP_I2C_SCLH_HSSCLH 8
|
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
/* I2C System Test Register (OMAP_I2C_SYSTEST): */
|
|
|
|
#define OMAP_I2C_SYSTEST_ST_EN (1 << 15) /* System test enable */
|
|
|
|
#define OMAP_I2C_SYSTEST_FREE (1 << 14) /* Free running mode */
|
|
|
|
#define OMAP_I2C_SYSTEST_TMODE_MASK (3 << 12) /* Test mode select */
|
|
|
|
#define OMAP_I2C_SYSTEST_TMODE_SHIFT (12) /* Test mode select */
|
2014-11-22 12:47:11 -07:00
|
|
|
/* Functional mode */
|
|
|
|
#define OMAP_I2C_SYSTEST_SCL_I_FUNC (1 << 8) /* SCL line input value */
|
|
|
|
#define OMAP_I2C_SYSTEST_SCL_O_FUNC (1 << 7) /* SCL line output value */
|
|
|
|
#define OMAP_I2C_SYSTEST_SDA_I_FUNC (1 << 6) /* SDA line input value */
|
|
|
|
#define OMAP_I2C_SYSTEST_SDA_O_FUNC (1 << 5) /* SDA line output value */
|
|
|
|
/* SDA/SCL IO mode */
|
2006-08-13 15:44:09 -06:00
|
|
|
#define OMAP_I2C_SYSTEST_SCL_I (1 << 3) /* SCL line sense in */
|
|
|
|
#define OMAP_I2C_SYSTEST_SCL_O (1 << 2) /* SCL line drive out */
|
|
|
|
#define OMAP_I2C_SYSTEST_SDA_I (1 << 1) /* SDA line sense in */
|
|
|
|
#define OMAP_I2C_SYSTEST_SDA_O (1 << 0) /* SDA line drive out */
|
|
|
|
|
2008-11-21 14:39:55 -07:00
|
|
|
/* OCP_SYSSTATUS bit definitions */
|
|
|
|
#define SYSS_RESETDONE_MASK (1 << 0)
|
|
|
|
|
|
|
|
/* OCP_SYSCONFIG bit definitions */
|
|
|
|
#define SYSC_CLOCKACTIVITY_MASK (0x3 << 8)
|
|
|
|
#define SYSC_SIDLEMODE_MASK (0x3 << 3)
|
|
|
|
#define SYSC_ENAWAKEUP_MASK (1 << 2)
|
|
|
|
#define SYSC_SOFTRESET_MASK (1 << 1)
|
|
|
|
#define SYSC_AUTOIDLE_MASK (1 << 0)
|
|
|
|
|
|
|
|
#define SYSC_IDLEMODE_SMART 0x2
|
|
|
|
#define SYSC_CLOCKACTIVITY_FCLK 0x2
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2010-05-11 12:35:20 -06:00
|
|
|
/* Errata definitions */
|
|
|
|
#define I2C_OMAP_ERRATA_I207 (1 << 0)
|
2012-05-29 04:56:22 -06:00
|
|
|
#define I2C_OMAP_ERRATA_I462 (1 << 1)
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2013-06-03 01:37:20 -06:00
|
|
|
#define OMAP_I2C_IP_V2_INTERRUPTS_MASK 0x6FFF
|
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
struct omap_i2c_dev {
|
|
|
|
struct device *dev;
|
|
|
|
void __iomem *base; /* virtual */
|
|
|
|
int irq;
|
2009-12-12 18:54:02 -07:00
|
|
|
int reg_shift; /* bit shift for I2C register addresses */
|
2006-08-13 15:44:09 -06:00
|
|
|
struct completion cmd_complete;
|
|
|
|
struct resource *ioarea;
|
2012-11-06 09:31:32 -07:00
|
|
|
u32 latency; /* maximum mpu wkup latency */
|
|
|
|
void (*set_mpu_wkup_lat)(struct device *dev,
|
|
|
|
long latency);
|
2011-12-22 07:56:36 -07:00
|
|
|
u32 speed; /* Speed of bus in kHz */
|
|
|
|
u32 flags;
|
2013-06-03 01:37:20 -06:00
|
|
|
u16 scheme;
|
2006-08-13 15:44:09 -06:00
|
|
|
u16 cmd_err;
|
|
|
|
u8 *buf;
|
2010-05-11 12:35:04 -06:00
|
|
|
u8 *regs;
|
2006-08-13 15:44:09 -06:00
|
|
|
size_t buf_len;
|
|
|
|
struct i2c_adapter adapter;
|
2012-09-12 04:58:10 -06:00
|
|
|
u8 threshold;
|
2008-11-21 14:39:46 -07:00
|
|
|
u8 fifo_size; /* use as flag and value
|
|
|
|
* fifo_size==0 implies no fifo
|
|
|
|
* if set, should be trsh+1
|
|
|
|
*/
|
2012-11-05 05:23:36 -07:00
|
|
|
u32 rev;
|
2008-11-21 14:39:46 -07:00
|
|
|
unsigned b_hw:1; /* bad h/w fixes */
|
2014-11-22 12:47:12 -07:00
|
|
|
unsigned bb_valid:1; /* true when BB-bit reflects
|
|
|
|
* the I2C bus state
|
|
|
|
*/
|
2012-09-12 04:58:06 -06:00
|
|
|
unsigned receiver:1; /* true when we're in receiver mode */
|
2008-03-23 13:28:20 -06:00
|
|
|
u16 iestate; /* Saved interrupt register */
|
2009-11-23 09:59:18 -07:00
|
|
|
u16 pscstate;
|
|
|
|
u16 scllstate;
|
|
|
|
u16 sclhstate;
|
|
|
|
u16 syscstate;
|
|
|
|
u16 westate;
|
2010-05-11 12:35:20 -06:00
|
|
|
u16 errata;
|
2006-08-13 15:44:09 -06:00
|
|
|
};
|
|
|
|
|
2011-05-30 08:43:06 -06:00
|
|
|
static const u8 reg_map_ip_v1[] = {
|
2010-05-11 12:35:04 -06:00
|
|
|
[OMAP_I2C_REV_REG] = 0x00,
|
|
|
|
[OMAP_I2C_IE_REG] = 0x01,
|
|
|
|
[OMAP_I2C_STAT_REG] = 0x02,
|
|
|
|
[OMAP_I2C_IV_REG] = 0x03,
|
|
|
|
[OMAP_I2C_WE_REG] = 0x03,
|
|
|
|
[OMAP_I2C_SYSS_REG] = 0x04,
|
|
|
|
[OMAP_I2C_BUF_REG] = 0x05,
|
|
|
|
[OMAP_I2C_CNT_REG] = 0x06,
|
|
|
|
[OMAP_I2C_DATA_REG] = 0x07,
|
|
|
|
[OMAP_I2C_SYSC_REG] = 0x08,
|
|
|
|
[OMAP_I2C_CON_REG] = 0x09,
|
|
|
|
[OMAP_I2C_OA_REG] = 0x0a,
|
|
|
|
[OMAP_I2C_SA_REG] = 0x0b,
|
|
|
|
[OMAP_I2C_PSC_REG] = 0x0c,
|
|
|
|
[OMAP_I2C_SCLL_REG] = 0x0d,
|
|
|
|
[OMAP_I2C_SCLH_REG] = 0x0e,
|
|
|
|
[OMAP_I2C_SYSTEST_REG] = 0x0f,
|
|
|
|
[OMAP_I2C_BUFSTAT_REG] = 0x10,
|
|
|
|
};
|
|
|
|
|
2011-05-30 08:43:06 -06:00
|
|
|
static const u8 reg_map_ip_v2[] = {
|
2010-05-11 12:35:04 -06:00
|
|
|
[OMAP_I2C_REV_REG] = 0x04,
|
|
|
|
[OMAP_I2C_IE_REG] = 0x2c,
|
|
|
|
[OMAP_I2C_STAT_REG] = 0x28,
|
|
|
|
[OMAP_I2C_IV_REG] = 0x34,
|
|
|
|
[OMAP_I2C_WE_REG] = 0x34,
|
|
|
|
[OMAP_I2C_SYSS_REG] = 0x90,
|
|
|
|
[OMAP_I2C_BUF_REG] = 0x94,
|
|
|
|
[OMAP_I2C_CNT_REG] = 0x98,
|
|
|
|
[OMAP_I2C_DATA_REG] = 0x9c,
|
2011-12-08 07:43:53 -07:00
|
|
|
[OMAP_I2C_SYSC_REG] = 0x10,
|
2010-05-11 12:35:04 -06:00
|
|
|
[OMAP_I2C_CON_REG] = 0xa4,
|
|
|
|
[OMAP_I2C_OA_REG] = 0xa8,
|
|
|
|
[OMAP_I2C_SA_REG] = 0xac,
|
|
|
|
[OMAP_I2C_PSC_REG] = 0xb0,
|
|
|
|
[OMAP_I2C_SCLL_REG] = 0xb4,
|
|
|
|
[OMAP_I2C_SCLH_REG] = 0xb8,
|
|
|
|
[OMAP_I2C_SYSTEST_REG] = 0xbC,
|
|
|
|
[OMAP_I2C_BUFSTAT_REG] = 0xc0,
|
2011-05-30 08:43:04 -06:00
|
|
|
[OMAP_I2C_IP_V2_REVNB_LO] = 0x00,
|
|
|
|
[OMAP_I2C_IP_V2_REVNB_HI] = 0x04,
|
|
|
|
[OMAP_I2C_IP_V2_IRQSTATUS_RAW] = 0x24,
|
|
|
|
[OMAP_I2C_IP_V2_IRQENABLE_SET] = 0x2c,
|
|
|
|
[OMAP_I2C_IP_V2_IRQENABLE_CLR] = 0x30,
|
2010-05-11 12:35:04 -06:00
|
|
|
};
|
|
|
|
|
2019-04-03 06:40:13 -06:00
|
|
|
static int omap_i2c_xfer_data(struct omap_i2c_dev *omap);
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
static inline void omap_i2c_write_reg(struct omap_i2c_dev *omap,
|
2006-08-13 15:44:09 -06:00
|
|
|
int reg, u16 val)
|
|
|
|
{
|
2015-07-13 14:38:03 -06:00
|
|
|
writew_relaxed(val, omap->base +
|
|
|
|
(omap->regs[reg] << omap->reg_shift));
|
2006-08-13 15:44:09 -06:00
|
|
|
}
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
static inline u16 omap_i2c_read_reg(struct omap_i2c_dev *omap, int reg)
|
2006-08-13 15:44:09 -06:00
|
|
|
{
|
2015-07-13 14:38:03 -06:00
|
|
|
return readw_relaxed(omap->base +
|
|
|
|
(omap->regs[reg] << omap->reg_shift));
|
2006-08-13 15:44:09 -06:00
|
|
|
}
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
static void __omap_i2c_init(struct omap_i2c_dev *omap)
|
2012-11-05 05:23:40 -07:00
|
|
|
{
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_CON_REG, 0);
|
2012-11-05 05:23:40 -07:00
|
|
|
|
|
|
|
/* Setup clock prescaler to obtain approx 12MHz I2C module clock: */
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_PSC_REG, omap->pscstate);
|
2012-11-05 05:23:40 -07:00
|
|
|
|
|
|
|
/* SCL low and high time values */
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_SCLL_REG, omap->scllstate);
|
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_SCLH_REG, omap->sclhstate);
|
|
|
|
if (omap->rev >= OMAP_I2C_REV_ON_3430_3530)
|
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_WE_REG, omap->westate);
|
2012-11-05 05:23:40 -07:00
|
|
|
|
|
|
|
/* Take the I2C module out of reset: */
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_CON_REG, OMAP_I2C_CON_EN);
|
2012-11-05 05:23:40 -07:00
|
|
|
|
2014-11-22 12:47:14 -07:00
|
|
|
/*
|
|
|
|
* NOTE: right after setting CON_EN, STAT_BB could be 0 while the
|
|
|
|
* bus is busy. It will be changed to 1 on the next IP FCLK clock.
|
|
|
|
* udelay(1) will be enough to fix that.
|
|
|
|
*/
|
|
|
|
|
2012-11-05 05:23:40 -07:00
|
|
|
/*
|
|
|
|
* Don't write to this register if the IE state is 0 as it can
|
|
|
|
* cause deadlock.
|
|
|
|
*/
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->iestate)
|
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_IE_REG, omap->iestate);
|
2012-11-05 05:23:40 -07:00
|
|
|
}
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
static int omap_i2c_reset(struct omap_i2c_dev *omap)
|
2006-08-13 15:44:09 -06:00
|
|
|
{
|
|
|
|
unsigned long timeout;
|
2012-11-05 05:23:43 -07:00
|
|
|
u16 sysc;
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->rev >= OMAP_I2C_OMAP1_REV_2) {
|
|
|
|
sysc = omap_i2c_read_reg(omap, OMAP_I2C_SYSC_REG);
|
2012-11-05 05:23:43 -07:00
|
|
|
|
2009-12-10 22:39:08 -07:00
|
|
|
/* Disable I2C controller before soft reset */
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_CON_REG,
|
|
|
|
omap_i2c_read_reg(omap, OMAP_I2C_CON_REG) &
|
2009-12-10 22:39:08 -07:00
|
|
|
~(OMAP_I2C_CON_EN));
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_SYSC_REG, SYSC_SOFTRESET_MASK);
|
2006-08-13 15:44:09 -06:00
|
|
|
/* For some reason we need to set the EN bit before the
|
|
|
|
* reset done bit gets set. */
|
|
|
|
timeout = jiffies + OMAP_I2C_TIMEOUT;
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_CON_REG, OMAP_I2C_CON_EN);
|
|
|
|
while (!(omap_i2c_read_reg(omap, OMAP_I2C_SYSS_REG) &
|
2008-11-21 14:39:55 -07:00
|
|
|
SYSS_RESETDONE_MASK)) {
|
2006-08-13 15:44:09 -06:00
|
|
|
if (time_after(jiffies, timeout)) {
|
2015-07-13 14:38:03 -06:00
|
|
|
dev_warn(omap->dev, "timeout waiting "
|
2006-08-13 15:44:09 -06:00
|
|
|
"for controller reset\n");
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
}
|
|
|
|
msleep(1);
|
|
|
|
}
|
2008-11-21 14:39:55 -07:00
|
|
|
|
|
|
|
/* SYSC register is cleared by the reset; rewrite it */
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_SYSC_REG, sysc);
|
2008-11-21 14:39:55 -07:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->rev > OMAP_I2C_REV_ON_3430_3530) {
|
2014-11-24 15:20:55 -07:00
|
|
|
/* Schedule I2C-bus monitoring on the next transfer */
|
2015-07-13 14:38:03 -06:00
|
|
|
omap->bb_valid = 0;
|
2014-11-24 15:20:55 -07:00
|
|
|
}
|
2006-08-13 15:44:09 -06:00
|
|
|
}
|
2014-11-22 12:47:12 -07:00
|
|
|
|
2012-11-05 05:23:41 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
static int omap_i2c_init(struct omap_i2c_dev *omap)
|
2012-11-05 05:23:41 -07:00
|
|
|
{
|
|
|
|
u16 psc = 0, scll = 0, sclh = 0;
|
|
|
|
u16 fsscll = 0, fssclh = 0, hsscll = 0, hssclh = 0;
|
|
|
|
unsigned long fclk_rate = 12000000;
|
|
|
|
unsigned long internal_clk = 0;
|
|
|
|
struct clk *fclk;
|
2017-10-16 15:06:14 -06:00
|
|
|
int error;
|
2012-11-05 05:23:41 -07:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->rev >= OMAP_I2C_REV_ON_3430_3530) {
|
2012-11-05 05:23:41 -07:00
|
|
|
/*
|
|
|
|
* Enabling all wakup sources to stop I2C freezing on
|
|
|
|
* WFI instruction.
|
|
|
|
* REVISIT: Some wkup sources might not be needed.
|
|
|
|
*/
|
2015-07-13 14:38:03 -06:00
|
|
|
omap->westate = OMAP_I2C_WE_ALL;
|
2012-11-05 05:23:41 -07:00
|
|
|
}
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->flags & OMAP_I2C_FLAG_ALWAYS_ARMXOR_CLK) {
|
2009-01-22 12:31:46 -07:00
|
|
|
/*
|
|
|
|
* The I2C functional clock is the armxor_ck, so there's
|
|
|
|
* no need to get "armxor_ck" separately. Now, if OMAP2420
|
|
|
|
* always returns 12MHz for the functional clock, we can
|
|
|
|
* do this bit unconditionally.
|
|
|
|
*/
|
2015-07-13 14:38:03 -06:00
|
|
|
fclk = clk_get(omap->dev, "fck");
|
2017-10-16 15:06:14 -06:00
|
|
|
if (IS_ERR(fclk)) {
|
|
|
|
error = PTR_ERR(fclk);
|
|
|
|
dev_err(omap->dev, "could not get fck: %i\n", error);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2010-09-28 09:32:58 -06:00
|
|
|
fclk_rate = clk_get_rate(fclk);
|
|
|
|
clk_put(fclk);
|
2009-01-22 12:31:46 -07:00
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
/* TRM for 5912 says the I2C clock must be prescaled to be
|
|
|
|
* between 7 - 12 MHz. The XOR input clock is typically
|
|
|
|
* 12, 13 or 19.2 MHz. So we should have code that produces:
|
|
|
|
*
|
|
|
|
* XOR MHz Divider Prescaler
|
|
|
|
* 12 1 0
|
|
|
|
* 13 2 1
|
|
|
|
* 19.2 2 1
|
|
|
|
*/
|
2006-12-10 13:21:34 -07:00
|
|
|
if (fclk_rate > 12000000)
|
|
|
|
psc = fclk_rate / 12000000;
|
2006-08-13 15:44:09 -06:00
|
|
|
}
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (!(omap->flags & OMAP_I2C_FLAG_SIMPLE_CLOCK)) {
|
2008-11-21 14:39:45 -07:00
|
|
|
|
2009-05-27 08:54:46 -06:00
|
|
|
/*
|
|
|
|
* HSI2C controller internal clk rate should be 19.2 Mhz for
|
|
|
|
* HS and for all modes on 2430. On 34xx we can use lower rate
|
|
|
|
* to get longer filter period for better noise suppression.
|
|
|
|
* The filter is iclk (fclk for HS) period.
|
|
|
|
*/
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->speed > 400 ||
|
|
|
|
omap->flags & OMAP_I2C_FLAG_FORCE_19200_INT_CLK)
|
2009-05-27 08:54:46 -06:00
|
|
|
internal_clk = 19200;
|
2015-07-13 14:38:03 -06:00
|
|
|
else if (omap->speed > 100)
|
2009-05-27 08:54:46 -06:00
|
|
|
internal_clk = 9600;
|
|
|
|
else
|
|
|
|
internal_clk = 4000;
|
2015-07-13 14:38:03 -06:00
|
|
|
fclk = clk_get(omap->dev, "fck");
|
2017-10-16 15:06:14 -06:00
|
|
|
if (IS_ERR(fclk)) {
|
|
|
|
error = PTR_ERR(fclk);
|
|
|
|
dev_err(omap->dev, "could not get fck: %i\n", error);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
2010-09-28 09:32:58 -06:00
|
|
|
fclk_rate = clk_get_rate(fclk) / 1000;
|
|
|
|
clk_put(fclk);
|
2008-11-21 14:39:45 -07:00
|
|
|
|
|
|
|
/* Compute prescaler divisor */
|
|
|
|
psc = fclk_rate / internal_clk;
|
|
|
|
psc = psc - 1;
|
|
|
|
|
|
|
|
/* If configured for High Speed */
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->speed > 400) {
|
2009-05-27 08:54:45 -06:00
|
|
|
unsigned long scl;
|
|
|
|
|
2008-11-21 14:39:45 -07:00
|
|
|
/* For first phase of HS mode */
|
2009-05-27 08:54:45 -06:00
|
|
|
scl = internal_clk / 400;
|
|
|
|
fsscll = scl - (scl / 3) - 7;
|
|
|
|
fssclh = (scl / 3) - 5;
|
2008-11-21 14:39:45 -07:00
|
|
|
|
|
|
|
/* For second phase of HS mode */
|
2015-07-13 14:38:03 -06:00
|
|
|
scl = fclk_rate / omap->speed;
|
2009-05-27 08:54:45 -06:00
|
|
|
hsscll = scl - (scl / 3) - 7;
|
|
|
|
hssclh = (scl / 3) - 5;
|
2015-07-13 14:38:03 -06:00
|
|
|
} else if (omap->speed > 100) {
|
2009-05-27 08:54:45 -06:00
|
|
|
unsigned long scl;
|
|
|
|
|
|
|
|
/* Fast mode */
|
2015-07-13 14:38:03 -06:00
|
|
|
scl = internal_clk / omap->speed;
|
2009-05-27 08:54:45 -06:00
|
|
|
fsscll = scl - (scl / 3) - 7;
|
|
|
|
fssclh = (scl / 3) - 5;
|
2008-11-21 14:39:45 -07:00
|
|
|
} else {
|
2009-05-27 08:54:45 -06:00
|
|
|
/* Standard mode */
|
2015-07-13 14:38:03 -06:00
|
|
|
fsscll = internal_clk / (omap->speed * 2) - 7;
|
|
|
|
fssclh = internal_clk / (omap->speed * 2) - 5;
|
2008-11-21 14:39:45 -07:00
|
|
|
}
|
|
|
|
scll = (hsscll << OMAP_I2C_SCLL_HSSCLL) | fsscll;
|
|
|
|
sclh = (hssclh << OMAP_I2C_SCLH_HSSCLH) | fssclh;
|
|
|
|
} else {
|
|
|
|
/* Program desired operating rate */
|
|
|
|
fclk_rate /= (psc + 1) * 1000;
|
|
|
|
if (psc > 2)
|
|
|
|
psc = 2;
|
2015-07-13 14:38:03 -06:00
|
|
|
scll = fclk_rate / (omap->speed * 2) - 7 + psc;
|
|
|
|
sclh = fclk_rate / (omap->speed * 2) - 7 + psc;
|
2008-11-21 14:39:45 -07:00
|
|
|
}
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
omap->iestate = (OMAP_I2C_IE_XRDY | OMAP_I2C_IE_RRDY |
|
2008-11-21 14:39:47 -07:00
|
|
|
OMAP_I2C_IE_ARDY | OMAP_I2C_IE_NACK |
|
2015-07-13 14:38:03 -06:00
|
|
|
OMAP_I2C_IE_AL) | ((omap->fifo_size) ?
|
2009-11-23 09:59:18 -07:00
|
|
|
(OMAP_I2C_IE_RDR | OMAP_I2C_IE_XDR) : 0);
|
2012-11-05 05:23:40 -07:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
omap->pscstate = psc;
|
|
|
|
omap->scllstate = scll;
|
|
|
|
omap->sclhstate = sclh;
|
2012-11-05 05:23:40 -07:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->rev <= OMAP_I2C_REV_ON_3430_3530) {
|
2014-11-22 12:47:12 -07:00
|
|
|
/* Not implemented */
|
2015-07-13 14:38:03 -06:00
|
|
|
omap->bb_valid = 1;
|
2014-11-22 12:47:12 -07:00
|
|
|
}
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
__omap_i2c_init(omap);
|
2012-11-05 05:23:40 -07:00
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-10-04 03:43:45 -06:00
|
|
|
/*
|
|
|
|
* Try bus recovery, but only if SDA is actually low.
|
|
|
|
*/
|
|
|
|
static int omap_i2c_recover_bus(struct omap_i2c_dev *omap)
|
|
|
|
{
|
|
|
|
u16 systest;
|
|
|
|
|
|
|
|
systest = omap_i2c_read_reg(omap, OMAP_I2C_SYSTEST_REG);
|
|
|
|
if ((systest & OMAP_I2C_SYSTEST_SCL_I_FUNC) &&
|
|
|
|
(systest & OMAP_I2C_SYSTEST_SDA_I_FUNC))
|
|
|
|
return 0; /* bus seems to already be fine */
|
|
|
|
if (!(systest & OMAP_I2C_SYSTEST_SCL_I_FUNC))
|
|
|
|
return -EBUSY; /* recovery would not fix SCL */
|
|
|
|
return i2c_recover_bus(&omap->adapter);
|
|
|
|
}
|
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
/*
|
|
|
|
* Waiting on Bus Busy
|
|
|
|
*/
|
2015-07-13 14:38:03 -06:00
|
|
|
static int omap_i2c_wait_for_bb(struct omap_i2c_dev *omap)
|
2006-08-13 15:44:09 -06:00
|
|
|
{
|
|
|
|
unsigned long timeout;
|
|
|
|
|
|
|
|
timeout = jiffies + OMAP_I2C_TIMEOUT;
|
2015-07-13 14:38:03 -06:00
|
|
|
while (omap_i2c_read_reg(omap, OMAP_I2C_STAT_REG) & OMAP_I2C_STAT_BB) {
|
2015-05-06 10:50:27 -06:00
|
|
|
if (time_after(jiffies, timeout))
|
2017-10-04 03:43:45 -06:00
|
|
|
return omap_i2c_recover_bus(omap);
|
2006-08-13 15:44:09 -06:00
|
|
|
msleep(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-11-22 12:47:12 -07:00
|
|
|
/*
|
|
|
|
* Wait while BB-bit doesn't reflect the I2C bus state
|
|
|
|
*
|
|
|
|
* In a multimaster environment, after IP software reset, BB-bit value doesn't
|
|
|
|
* correspond to the current bus state. It may happen what BB-bit will be 0,
|
|
|
|
* while the bus is busy due to another I2C master activity.
|
|
|
|
* Here are BB-bit values after reset:
|
|
|
|
* SDA SCL BB NOTES
|
|
|
|
* 0 0 0 1, 2
|
|
|
|
* 1 0 0 1, 2
|
|
|
|
* 0 1 1
|
|
|
|
* 1 1 0 3
|
|
|
|
* Later, if IP detect SDA=0 and SCL=1 (ACK) or SDA 1->0 while SCL=1 (START)
|
|
|
|
* combinations on the bus, it set BB-bit to 1.
|
|
|
|
* If IP detect SDA 0->1 while SCL=1 (STOP) combination on the bus,
|
|
|
|
* it set BB-bit to 0 and BF to 1.
|
|
|
|
* BB and BF bits correctly tracks the bus state while IP is suspended
|
|
|
|
* BB bit became valid on the next FCLK clock after CON_EN bit set
|
|
|
|
*
|
|
|
|
* NOTES:
|
|
|
|
* 1. Any transfer started when BB=0 and bus is busy wouldn't be
|
|
|
|
* completed by IP and results in controller timeout.
|
|
|
|
* 2. Any transfer started when BB=0 and SCL=0 results in IP
|
|
|
|
* starting to drive SDA low. In that case IP corrupt data
|
|
|
|
* on the bus.
|
|
|
|
* 3. Any transfer started in the middle of another master's transfer
|
|
|
|
* results in unpredictable results and data corruption
|
|
|
|
*/
|
2015-07-13 14:38:03 -06:00
|
|
|
static int omap_i2c_wait_for_bb_valid(struct omap_i2c_dev *omap)
|
2014-11-22 12:47:12 -07:00
|
|
|
{
|
|
|
|
unsigned long bus_free_timeout = 0;
|
|
|
|
unsigned long timeout;
|
|
|
|
int bus_free = 0;
|
|
|
|
u16 stat, systest;
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->bb_valid)
|
2014-11-22 12:47:12 -07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
timeout = jiffies + OMAP_I2C_TIMEOUT;
|
|
|
|
while (1) {
|
2015-07-13 14:38:03 -06:00
|
|
|
stat = omap_i2c_read_reg(omap, OMAP_I2C_STAT_REG);
|
2014-11-22 12:47:12 -07:00
|
|
|
/*
|
|
|
|
* We will see BB or BF event in a case IP had detected any
|
|
|
|
* activity on the I2C bus. Now IP correctly tracks the bus
|
|
|
|
* state. BB-bit value is valid.
|
|
|
|
*/
|
|
|
|
if (stat & (OMAP_I2C_STAT_BB | OMAP_I2C_STAT_BF))
|
|
|
|
break;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Otherwise, we must look signals on the bus to make
|
|
|
|
* the right decision.
|
|
|
|
*/
|
2015-07-13 14:38:03 -06:00
|
|
|
systest = omap_i2c_read_reg(omap, OMAP_I2C_SYSTEST_REG);
|
2014-11-22 12:47:12 -07:00
|
|
|
if ((systest & OMAP_I2C_SYSTEST_SCL_I_FUNC) &&
|
|
|
|
(systest & OMAP_I2C_SYSTEST_SDA_I_FUNC)) {
|
|
|
|
if (!bus_free) {
|
|
|
|
bus_free_timeout = jiffies +
|
|
|
|
OMAP_I2C_BUS_FREE_TIMEOUT;
|
|
|
|
bus_free = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* SDA and SCL lines was high for 10 ms without bus
|
|
|
|
* activity detected. The bus is free. Consider
|
|
|
|
* BB-bit value is valid.
|
|
|
|
*/
|
|
|
|
if (time_after(jiffies, bus_free_timeout))
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
bus_free = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (time_after(jiffies, timeout)) {
|
2017-10-04 03:43:45 -06:00
|
|
|
/*
|
|
|
|
* SDA or SCL were low for the entire timeout without
|
|
|
|
* any activity detected. Most likely, a slave is
|
|
|
|
* locking up the bus with no master driving the clock.
|
|
|
|
*/
|
2015-07-13 14:38:03 -06:00
|
|
|
dev_warn(omap->dev, "timeout waiting for bus ready\n");
|
2017-10-04 03:43:45 -06:00
|
|
|
return omap_i2c_recover_bus(omap);
|
2014-11-22 12:47:12 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
msleep(1);
|
|
|
|
}
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
omap->bb_valid = 1;
|
2014-11-22 12:47:12 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
static void omap_i2c_resize_fifo(struct omap_i2c_dev *omap, u8 size, bool is_rx)
|
2012-09-12 04:58:10 -06:00
|
|
|
{
|
|
|
|
u16 buf;
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->flags & OMAP_I2C_FLAG_NO_FIFO)
|
2012-09-12 04:58:10 -06:00
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set up notification threshold based on message size. We're doing
|
|
|
|
* this to try and avoid draining feature as much as possible. Whenever
|
|
|
|
* we have big messages to transfer (bigger than our total fifo size)
|
|
|
|
* then we might use draining feature to transfer the remaining bytes.
|
|
|
|
*/
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
omap->threshold = clamp(size, (u8) 1, omap->fifo_size);
|
2012-09-12 04:58:10 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
buf = omap_i2c_read_reg(omap, OMAP_I2C_BUF_REG);
|
2012-09-12 04:58:10 -06:00
|
|
|
|
|
|
|
if (is_rx) {
|
|
|
|
/* Clear RX Threshold */
|
|
|
|
buf &= ~(0x3f << 8);
|
2015-07-13 14:38:03 -06:00
|
|
|
buf |= ((omap->threshold - 1) << 8) | OMAP_I2C_BUF_RXFIF_CLR;
|
2012-09-12 04:58:10 -06:00
|
|
|
} else {
|
|
|
|
/* Clear TX Threshold */
|
|
|
|
buf &= ~0x3f;
|
2015-07-13 14:38:03 -06:00
|
|
|
buf |= (omap->threshold - 1) | OMAP_I2C_BUF_TXFIF_CLR;
|
2012-09-12 04:58:10 -06:00
|
|
|
}
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_BUF_REG, buf);
|
2012-09-12 04:58:10 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->rev < OMAP_I2C_REV_ON_3630)
|
|
|
|
omap->b_hw = 1; /* Enable hardware fixes */
|
2012-09-12 04:58:10 -06:00
|
|
|
|
|
|
|
/* calculate wakeup latency constraint for MPU */
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->set_mpu_wkup_lat != NULL)
|
|
|
|
omap->latency = (1000000 * omap->threshold) /
|
|
|
|
(1000 * omap->speed / 8);
|
2012-09-12 04:58:10 -06:00
|
|
|
}
|
|
|
|
|
2019-04-03 06:40:13 -06:00
|
|
|
static void omap_i2c_wait(struct omap_i2c_dev *omap)
|
|
|
|
{
|
|
|
|
u16 stat;
|
|
|
|
u16 mask = omap_i2c_read_reg(omap, OMAP_I2C_IE_REG);
|
|
|
|
int count = 0;
|
|
|
|
|
|
|
|
do {
|
|
|
|
stat = omap_i2c_read_reg(omap, OMAP_I2C_STAT_REG);
|
|
|
|
count++;
|
|
|
|
} while (!(stat & mask) && count < 5);
|
|
|
|
}
|
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
/*
|
|
|
|
* Low level master read/write transaction.
|
|
|
|
*/
|
|
|
|
static int omap_i2c_xfer_msg(struct i2c_adapter *adap,
|
2019-04-03 06:40:13 -06:00
|
|
|
struct i2c_msg *msg, int stop, bool polling)
|
2006-08-13 15:44:09 -06:00
|
|
|
{
|
2015-07-13 14:38:03 -06:00
|
|
|
struct omap_i2c_dev *omap = i2c_get_adapdata(adap);
|
2012-05-29 04:56:17 -06:00
|
|
|
unsigned long timeout;
|
2006-08-13 15:44:09 -06:00
|
|
|
u16 w;
|
2019-04-03 06:40:13 -06:00
|
|
|
int ret;
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
dev_dbg(omap->dev, "addr: 0x%04x, len: %d, flags: 0x%x, stop: %d\n",
|
2006-08-13 15:44:09 -06:00
|
|
|
msg->addr, msg->len, msg->flags, stop);
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
omap->receiver = !!(msg->flags & I2C_M_RD);
|
|
|
|
omap_i2c_resize_fifo(omap, msg->len, omap->receiver);
|
2012-09-12 04:58:10 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_SA_REG, msg->addr);
|
2006-08-13 15:44:09 -06:00
|
|
|
|
|
|
|
/* REVISIT: Could the STB bit of I2C_CON be used with probing? */
|
2015-07-13 14:38:03 -06:00
|
|
|
omap->buf = msg->buf;
|
|
|
|
omap->buf_len = msg->len;
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
/* make sure writes to omap->buf_len are ordered */
|
2012-11-14 07:22:45 -07:00
|
|
|
barrier();
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_CNT_REG, omap->buf_len);
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2008-11-21 14:39:46 -07:00
|
|
|
/* Clear the FIFO Buffers */
|
2015-07-13 14:38:03 -06:00
|
|
|
w = omap_i2c_read_reg(omap, OMAP_I2C_BUF_REG);
|
2008-11-21 14:39:46 -07:00
|
|
|
w |= OMAP_I2C_BUF_RXFIF_CLR | OMAP_I2C_BUF_TXFIF_CLR;
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_BUF_REG, w);
|
2008-11-21 14:39:46 -07:00
|
|
|
|
2019-04-03 06:40:13 -06:00
|
|
|
if (!polling)
|
|
|
|
reinit_completion(&omap->cmd_complete);
|
2015-07-13 14:38:03 -06:00
|
|
|
omap->cmd_err = 0;
|
2006-08-13 15:44:09 -06:00
|
|
|
|
|
|
|
w = OMAP_I2C_CON_EN | OMAP_I2C_CON_MST | OMAP_I2C_CON_STT;
|
2008-11-21 14:39:45 -07:00
|
|
|
|
|
|
|
/* High speed configuration */
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->speed > 400)
|
2008-11-21 14:39:46 -07:00
|
|
|
w |= OMAP_I2C_CON_OPMODE_HS;
|
2008-11-21 14:39:45 -07:00
|
|
|
|
2012-07-24 06:13:59 -06:00
|
|
|
if (msg->flags & I2C_M_STOP)
|
|
|
|
stop = 1;
|
2006-08-13 15:44:09 -06:00
|
|
|
if (msg->flags & I2C_M_TEN)
|
|
|
|
w |= OMAP_I2C_CON_XA;
|
|
|
|
if (!(msg->flags & I2C_M_RD))
|
|
|
|
w |= OMAP_I2C_CON_TRX;
|
2008-11-21 14:39:47 -07:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (!omap->b_hw && stop)
|
2006-08-13 15:44:09 -06:00
|
|
|
w |= OMAP_I2C_CON_STP;
|
2014-11-22 12:47:14 -07:00
|
|
|
/*
|
|
|
|
* NOTE: STAT_BB bit could became 1 here if another master occupy
|
|
|
|
* the bus. IP successfully complete transfer when the bus will be
|
|
|
|
* free again (BB reset to 0).
|
|
|
|
*/
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_CON_REG, w);
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2008-11-21 14:39:46 -07:00
|
|
|
/*
|
|
|
|
* Don't write stt and stp together on some hardware.
|
|
|
|
*/
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->b_hw && stop) {
|
2008-11-21 14:39:46 -07:00
|
|
|
unsigned long delay = jiffies + OMAP_I2C_TIMEOUT;
|
2015-07-13 14:38:03 -06:00
|
|
|
u16 con = omap_i2c_read_reg(omap, OMAP_I2C_CON_REG);
|
2008-11-21 14:39:46 -07:00
|
|
|
while (con & OMAP_I2C_CON_STT) {
|
2015-07-13 14:38:03 -06:00
|
|
|
con = omap_i2c_read_reg(omap, OMAP_I2C_CON_REG);
|
2008-11-21 14:39:46 -07:00
|
|
|
|
|
|
|
/* Let the user know if i2c is in a bad state */
|
|
|
|
if (time_after(jiffies, delay)) {
|
2015-07-13 14:38:03 -06:00
|
|
|
dev_err(omap->dev, "controller timed out "
|
2008-11-21 14:39:46 -07:00
|
|
|
"waiting for start condition to finish\n");
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
}
|
|
|
|
cpu_relax();
|
|
|
|
}
|
|
|
|
|
|
|
|
w |= OMAP_I2C_CON_STP;
|
|
|
|
w &= ~OMAP_I2C_CON_STT;
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_CON_REG, w);
|
2008-11-21 14:39:46 -07:00
|
|
|
}
|
|
|
|
|
2008-11-21 14:39:45 -07:00
|
|
|
/*
|
|
|
|
* REVISIT: We should abort the transfer on signals, but the bus goes
|
|
|
|
* into arbitration and we're currently unable to recover from it.
|
|
|
|
*/
|
2019-04-03 06:40:13 -06:00
|
|
|
if (!polling) {
|
|
|
|
timeout = wait_for_completion_timeout(&omap->cmd_complete,
|
|
|
|
OMAP_I2C_TIMEOUT);
|
|
|
|
} else {
|
|
|
|
do {
|
|
|
|
omap_i2c_wait(omap);
|
|
|
|
ret = omap_i2c_xfer_data(omap);
|
|
|
|
} while (ret == -EAGAIN);
|
|
|
|
|
|
|
|
timeout = !ret;
|
|
|
|
}
|
|
|
|
|
2012-05-29 04:56:17 -06:00
|
|
|
if (timeout == 0) {
|
2015-07-13 14:38:03 -06:00
|
|
|
dev_err(omap->dev, "controller timed out\n");
|
|
|
|
omap_i2c_reset(omap);
|
|
|
|
__omap_i2c_init(omap);
|
2006-08-13 15:44:09 -06:00
|
|
|
return -ETIMEDOUT;
|
|
|
|
}
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (likely(!omap->cmd_err))
|
2006-08-13 15:44:09 -06:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* We have an error */
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->cmd_err & (OMAP_I2C_STAT_ROVR | OMAP_I2C_STAT_XUDF)) {
|
|
|
|
omap_i2c_reset(omap);
|
|
|
|
__omap_i2c_init(omap);
|
2006-08-13 15:44:09 -06:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->cmd_err & OMAP_I2C_STAT_AL)
|
2014-11-22 12:47:13 -07:00
|
|
|
return -EAGAIN;
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->cmd_err & OMAP_I2C_STAT_NACK) {
|
2006-08-13 15:44:09 -06:00
|
|
|
if (msg->flags & I2C_M_IGNORE_NAK)
|
|
|
|
return 0;
|
2013-06-07 12:46:07 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
w = omap_i2c_read_reg(omap, OMAP_I2C_CON_REG);
|
2013-06-07 12:46:07 -06:00
|
|
|
w |= OMAP_I2C_CON_STP;
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_CON_REG, w);
|
2006-08-13 15:44:09 -06:00
|
|
|
return -EREMOTEIO;
|
|
|
|
}
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Prepare controller for a transaction and call omap_i2c_xfer_msg
|
|
|
|
* to do the work during IRQ processing.
|
|
|
|
*/
|
|
|
|
static int
|
2019-04-03 06:40:13 -06:00
|
|
|
omap_i2c_xfer_common(struct i2c_adapter *adap, struct i2c_msg msgs[], int num,
|
|
|
|
bool polling)
|
2006-08-13 15:44:09 -06:00
|
|
|
{
|
2015-07-13 14:38:03 -06:00
|
|
|
struct omap_i2c_dev *omap = i2c_get_adapdata(adap);
|
2006-08-13 15:44:09 -06:00
|
|
|
int i;
|
|
|
|
int r;
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
r = pm_runtime_get_sync(omap->dev);
|
2014-03-27 10:18:33 -06:00
|
|
|
if (r < 0)
|
2012-06-26 19:45:32 -06:00
|
|
|
goto out;
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
r = omap_i2c_wait_for_bb_valid(omap);
|
2014-11-22 12:47:12 -07:00
|
|
|
if (r < 0)
|
|
|
|
goto out;
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
r = omap_i2c_wait_for_bb(omap);
|
2008-11-21 14:39:47 -07:00
|
|
|
if (r < 0)
|
2006-08-13 15:44:09 -06:00
|
|
|
goto out;
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->set_mpu_wkup_lat != NULL)
|
|
|
|
omap->set_mpu_wkup_lat(omap->dev, omap->latency);
|
2010-11-18 03:04:20 -07:00
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
for (i = 0; i < num; i++) {
|
2019-04-03 06:40:13 -06:00
|
|
|
r = omap_i2c_xfer_msg(adap, &msgs[i], (i == (num - 1)),
|
|
|
|
polling);
|
2006-08-13 15:44:09 -06:00
|
|
|
if (r != 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (r == 0)
|
|
|
|
r = num;
|
2010-08-26 01:36:44 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_wait_for_bb(omap);
|
2012-11-15 01:49:21 -07:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->set_mpu_wkup_lat != NULL)
|
|
|
|
omap->set_mpu_wkup_lat(omap->dev, -1);
|
2012-11-15 01:49:21 -07:00
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
out:
|
2015-07-13 14:38:03 -06:00
|
|
|
pm_runtime_mark_last_busy(omap->dev);
|
|
|
|
pm_runtime_put_autosuspend(omap->dev);
|
2006-08-13 15:44:09 -06:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2019-04-03 06:40:13 -06:00
|
|
|
static int
|
|
|
|
omap_i2c_xfer_irq(struct i2c_adapter *adap, struct i2c_msg msgs[], int num)
|
|
|
|
{
|
|
|
|
return omap_i2c_xfer_common(adap, msgs, num, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
omap_i2c_xfer_polling(struct i2c_adapter *adap, struct i2c_msg msgs[], int num)
|
|
|
|
{
|
|
|
|
return omap_i2c_xfer_common(adap, msgs, num, true);
|
|
|
|
}
|
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
static u32
|
|
|
|
omap_i2c_func(struct i2c_adapter *adap)
|
|
|
|
{
|
2012-07-24 06:13:59 -06:00
|
|
|
return I2C_FUNC_I2C | (I2C_FUNC_SMBUS_EMUL & ~I2C_FUNC_SMBUS_QUICK) |
|
|
|
|
I2C_FUNC_PROTOCOL_MANGLING;
|
2006-08-13 15:44:09 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_complete_cmd(struct omap_i2c_dev *omap, u16 err)
|
2006-08-13 15:44:09 -06:00
|
|
|
{
|
2015-07-13 14:38:03 -06:00
|
|
|
omap->cmd_err |= err;
|
|
|
|
complete(&omap->cmd_complete);
|
2006-08-13 15:44:09 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_ack_stat(struct omap_i2c_dev *omap, u16 stat)
|
2006-08-13 15:44:09 -06:00
|
|
|
{
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_STAT_REG, stat);
|
2006-08-13 15:44:09 -06:00
|
|
|
}
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
static inline void i2c_omap_errata_i207(struct omap_i2c_dev *omap, u16 stat)
|
2010-05-11 12:35:20 -06:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* I2C Errata(Errata Nos. OMAP2: 1.67, OMAP3: 1.8)
|
|
|
|
* Not applicable for OMAP4.
|
|
|
|
* Under certain rare conditions, RDR could be set again
|
|
|
|
* when the bus is busy, then ignore the interrupt and
|
|
|
|
* clear the interrupt.
|
|
|
|
*/
|
|
|
|
if (stat & OMAP_I2C_STAT_RDR) {
|
|
|
|
/* Step 1: If RDR is set, clear it */
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_ack_stat(omap, OMAP_I2C_STAT_RDR);
|
2010-05-11 12:35:20 -06:00
|
|
|
|
|
|
|
/* Step 2: */
|
2015-07-13 14:38:03 -06:00
|
|
|
if (!(omap_i2c_read_reg(omap, OMAP_I2C_STAT_REG)
|
2010-05-11 12:35:20 -06:00
|
|
|
& OMAP_I2C_STAT_BB)) {
|
|
|
|
|
|
|
|
/* Step 3: */
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap_i2c_read_reg(omap, OMAP_I2C_STAT_REG)
|
2010-05-11 12:35:20 -06:00
|
|
|
& OMAP_I2C_STAT_RDR) {
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_ack_stat(omap, OMAP_I2C_STAT_RDR);
|
|
|
|
dev_dbg(omap->dev, "RDR when bus is busy.\n");
|
2010-05-11 12:35:20 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-11-21 14:39:47 -07:00
|
|
|
/* rev1 devices are apparently only on some 15xx */
|
|
|
|
#ifdef CONFIG_ARCH_OMAP15XX
|
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
static irqreturn_t
|
2011-05-30 08:43:07 -06:00
|
|
|
omap_i2c_omap1_isr(int this_irq, void *dev_id)
|
2006-08-13 15:44:09 -06:00
|
|
|
{
|
2015-07-13 14:38:03 -06:00
|
|
|
struct omap_i2c_dev *omap = dev_id;
|
2006-08-13 15:44:09 -06:00
|
|
|
u16 iv, w;
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (pm_runtime_suspended(omap->dev))
|
2008-03-23 13:28:20 -06:00
|
|
|
return IRQ_NONE;
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
iv = omap_i2c_read_reg(omap, OMAP_I2C_IV_REG);
|
2006-08-13 15:44:09 -06:00
|
|
|
switch (iv) {
|
|
|
|
case 0x00: /* None */
|
|
|
|
break;
|
|
|
|
case 0x01: /* Arbitration lost */
|
2015-07-13 14:38:03 -06:00
|
|
|
dev_err(omap->dev, "Arbitration lost\n");
|
|
|
|
omap_i2c_complete_cmd(omap, OMAP_I2C_STAT_AL);
|
2006-08-13 15:44:09 -06:00
|
|
|
break;
|
|
|
|
case 0x02: /* No acknowledgement */
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_complete_cmd(omap, OMAP_I2C_STAT_NACK);
|
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_CON_REG, OMAP_I2C_CON_STP);
|
2006-08-13 15:44:09 -06:00
|
|
|
break;
|
|
|
|
case 0x03: /* Register access ready */
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_complete_cmd(omap, 0);
|
2006-08-13 15:44:09 -06:00
|
|
|
break;
|
|
|
|
case 0x04: /* Receive data ready */
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->buf_len) {
|
|
|
|
w = omap_i2c_read_reg(omap, OMAP_I2C_DATA_REG);
|
|
|
|
*omap->buf++ = w;
|
|
|
|
omap->buf_len--;
|
|
|
|
if (omap->buf_len) {
|
|
|
|
*omap->buf++ = w >> 8;
|
|
|
|
omap->buf_len--;
|
2006-08-13 15:44:09 -06:00
|
|
|
}
|
|
|
|
} else
|
2015-07-13 14:38:03 -06:00
|
|
|
dev_err(omap->dev, "RRDY IRQ while no data requested\n");
|
2006-08-13 15:44:09 -06:00
|
|
|
break;
|
|
|
|
case 0x05: /* Transmit data ready */
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->buf_len) {
|
|
|
|
w = *omap->buf++;
|
|
|
|
omap->buf_len--;
|
|
|
|
if (omap->buf_len) {
|
|
|
|
w |= *omap->buf++ << 8;
|
|
|
|
omap->buf_len--;
|
2006-08-13 15:44:09 -06:00
|
|
|
}
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_DATA_REG, w);
|
2006-08-13 15:44:09 -06:00
|
|
|
} else
|
2015-07-13 14:38:03 -06:00
|
|
|
dev_err(omap->dev, "XRDY IRQ while no data to send\n");
|
2006-08-13 15:44:09 -06:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return IRQ_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
2008-11-21 14:39:47 -07:00
|
|
|
#else
|
2011-05-30 08:43:07 -06:00
|
|
|
#define omap_i2c_omap1_isr NULL
|
2008-11-21 14:39:47 -07:00
|
|
|
#endif
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2010-05-11 12:35:14 -06:00
|
|
|
/*
|
2012-05-29 04:56:22 -06:00
|
|
|
* OMAP3430 Errata i462: When an XRDY/XDR is hit, wait for XUDF before writing
|
2010-05-11 12:35:14 -06:00
|
|
|
* data to DATA_REG. Otherwise some data bytes can be lost while transferring
|
|
|
|
* them from the memory to the I2C interface.
|
|
|
|
*/
|
2015-07-13 14:38:03 -06:00
|
|
|
static int errata_omap3_i462(struct omap_i2c_dev *omap)
|
2010-05-11 12:35:14 -06:00
|
|
|
{
|
2010-05-11 12:35:17 -06:00
|
|
|
unsigned long timeout = 10000;
|
2012-09-12 04:58:01 -06:00
|
|
|
u16 stat;
|
2010-05-11 12:35:17 -06:00
|
|
|
|
2012-09-12 04:58:01 -06:00
|
|
|
do {
|
2015-07-13 14:38:03 -06:00
|
|
|
stat = omap_i2c_read_reg(omap, OMAP_I2C_STAT_REG);
|
2012-09-12 04:58:01 -06:00
|
|
|
if (stat & OMAP_I2C_STAT_XUDF)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (stat & (OMAP_I2C_STAT_NACK | OMAP_I2C_STAT_AL)) {
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_ack_stat(omap, (OMAP_I2C_STAT_XRDY |
|
2010-05-11 12:35:14 -06:00
|
|
|
OMAP_I2C_STAT_XDR));
|
2012-09-12 04:58:11 -06:00
|
|
|
if (stat & OMAP_I2C_STAT_NACK) {
|
2015-07-13 14:38:03 -06:00
|
|
|
omap->cmd_err |= OMAP_I2C_STAT_NACK;
|
|
|
|
omap_i2c_ack_stat(omap, OMAP_I2C_STAT_NACK);
|
2012-09-12 04:58:11 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (stat & OMAP_I2C_STAT_AL) {
|
2015-07-13 14:38:03 -06:00
|
|
|
dev_err(omap->dev, "Arbitration lost\n");
|
|
|
|
omap->cmd_err |= OMAP_I2C_STAT_AL;
|
|
|
|
omap_i2c_ack_stat(omap, OMAP_I2C_STAT_AL);
|
2012-09-12 04:58:11 -06:00
|
|
|
}
|
|
|
|
|
2012-09-12 04:58:01 -06:00
|
|
|
return -EIO;
|
2010-05-11 12:35:14 -06:00
|
|
|
}
|
2010-05-11 12:35:17 -06:00
|
|
|
|
2010-05-11 12:35:14 -06:00
|
|
|
cpu_relax();
|
2012-09-12 04:58:01 -06:00
|
|
|
} while (--timeout);
|
2010-05-11 12:35:14 -06:00
|
|
|
|
2010-05-11 12:35:17 -06:00
|
|
|
if (!timeout) {
|
2015-07-13 14:38:03 -06:00
|
|
|
dev_err(omap->dev, "timeout waiting on XUDF bit\n");
|
2010-05-11 12:35:17 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-05-11 12:35:14 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
static void omap_i2c_receive_data(struct omap_i2c_dev *omap, u8 num_bytes,
|
2012-09-12 04:58:02 -06:00
|
|
|
bool is_rdr)
|
|
|
|
{
|
|
|
|
u16 w;
|
|
|
|
|
|
|
|
while (num_bytes--) {
|
2015-07-13 14:38:03 -06:00
|
|
|
w = omap_i2c_read_reg(omap, OMAP_I2C_DATA_REG);
|
|
|
|
*omap->buf++ = w;
|
|
|
|
omap->buf_len--;
|
2012-09-12 04:58:02 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Data reg in 2430, omap3 and
|
|
|
|
* omap4 is 8 bit wide
|
|
|
|
*/
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->flags & OMAP_I2C_FLAG_16BIT_DATA_REG) {
|
|
|
|
*omap->buf++ = w >> 8;
|
|
|
|
omap->buf_len--;
|
2012-09-12 04:58:02 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
static int omap_i2c_transmit_data(struct omap_i2c_dev *omap, u8 num_bytes,
|
2012-09-12 04:58:02 -06:00
|
|
|
bool is_xdr)
|
|
|
|
{
|
|
|
|
u16 w;
|
|
|
|
|
|
|
|
while (num_bytes--) {
|
2015-07-13 14:38:03 -06:00
|
|
|
w = *omap->buf++;
|
|
|
|
omap->buf_len--;
|
2012-09-12 04:58:02 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Data reg in 2430, omap3 and
|
|
|
|
* omap4 is 8 bit wide
|
|
|
|
*/
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->flags & OMAP_I2C_FLAG_16BIT_DATA_REG) {
|
|
|
|
w |= *omap->buf++ << 8;
|
|
|
|
omap->buf_len--;
|
2012-09-12 04:58:02 -06:00
|
|
|
}
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->errata & I2C_OMAP_ERRATA_I462) {
|
2012-09-12 04:58:02 -06:00
|
|
|
int ret;
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
ret = errata_omap3_i462(omap);
|
2012-09-12 04:58:02 -06:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_DATA_REG, w);
|
2012-09-12 04:58:02 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
static irqreturn_t
|
2012-09-12 04:58:13 -06:00
|
|
|
omap_i2c_isr(int irq, void *dev_id)
|
2006-08-13 15:44:09 -06:00
|
|
|
{
|
2015-07-13 14:38:03 -06:00
|
|
|
struct omap_i2c_dev *omap = dev_id;
|
2012-09-12 04:58:13 -06:00
|
|
|
irqreturn_t ret = IRQ_HANDLED;
|
|
|
|
u16 mask;
|
|
|
|
u16 stat;
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
stat = omap_i2c_read_reg(omap, OMAP_I2C_STAT_REG);
|
2016-04-04 07:55:23 -06:00
|
|
|
mask = omap_i2c_read_reg(omap, OMAP_I2C_IE_REG);
|
2012-09-12 04:58:13 -06:00
|
|
|
|
|
|
|
if (stat & mask)
|
|
|
|
ret = IRQ_WAKE_THREAD;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-04-03 06:40:13 -06:00
|
|
|
static int omap_i2c_xfer_data(struct omap_i2c_dev *omap)
|
2006-08-13 15:44:09 -06:00
|
|
|
{
|
|
|
|
u16 bits;
|
2012-09-12 04:58:02 -06:00
|
|
|
u16 stat;
|
2012-09-12 04:58:03 -06:00
|
|
|
int err = 0, count = 0;
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2012-09-12 04:58:03 -06:00
|
|
|
do {
|
2015-07-13 14:38:03 -06:00
|
|
|
bits = omap_i2c_read_reg(omap, OMAP_I2C_IE_REG);
|
|
|
|
stat = omap_i2c_read_reg(omap, OMAP_I2C_STAT_REG);
|
2012-09-12 04:58:03 -06:00
|
|
|
stat &= bits;
|
|
|
|
|
2012-09-12 04:58:06 -06:00
|
|
|
/* If we're in receiver mode, ignore XDR/XRDY */
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->receiver)
|
2012-09-12 04:58:06 -06:00
|
|
|
stat &= ~(OMAP_I2C_STAT_XDR | OMAP_I2C_STAT_XRDY);
|
|
|
|
else
|
|
|
|
stat &= ~(OMAP_I2C_STAT_RDR | OMAP_I2C_STAT_RRDY);
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2012-09-12 04:58:03 -06:00
|
|
|
if (!stat) {
|
|
|
|
/* my work here is done */
|
2019-04-03 06:40:13 -06:00
|
|
|
err = -EAGAIN;
|
|
|
|
break;
|
2012-09-12 04:58:03 -06:00
|
|
|
}
|
2008-03-23 13:28:20 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
dev_dbg(omap->dev, "IRQ (ISR = 0x%04x)\n", stat);
|
2006-08-13 15:44:09 -06:00
|
|
|
if (count++ == 100) {
|
2015-07-13 14:38:03 -06:00
|
|
|
dev_warn(omap->dev, "Too much work in one IRQ\n");
|
2006-08-13 15:44:09 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2012-09-12 04:58:04 -06:00
|
|
|
if (stat & OMAP_I2C_STAT_NACK) {
|
2008-11-21 14:39:46 -07:00
|
|
|
err |= OMAP_I2C_STAT_NACK;
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_ack_stat(omap, OMAP_I2C_STAT_NACK);
|
2012-09-12 04:58:04 -06:00
|
|
|
}
|
2011-12-07 12:50:16 -07:00
|
|
|
|
2008-11-21 14:39:46 -07:00
|
|
|
if (stat & OMAP_I2C_STAT_AL) {
|
2015-07-13 14:38:03 -06:00
|
|
|
dev_err(omap->dev, "Arbitration lost\n");
|
2008-11-21 14:39:46 -07:00
|
|
|
err |= OMAP_I2C_STAT_AL;
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_ack_stat(omap, OMAP_I2C_STAT_AL);
|
2008-11-21 14:39:46 -07:00
|
|
|
}
|
2012-09-12 04:57:58 -06:00
|
|
|
|
2011-02-22 17:43:55 -07:00
|
|
|
/*
|
2011-02-15 21:54:16 -07:00
|
|
|
* ProDB0017052: Clear ARDY bit twice
|
2011-02-22 17:43:55 -07:00
|
|
|
*/
|
2013-10-07 04:41:59 -06:00
|
|
|
if (stat & OMAP_I2C_STAT_ARDY)
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_ack_stat(omap, OMAP_I2C_STAT_ARDY);
|
2013-10-07 04:41:59 -06:00
|
|
|
|
2008-11-21 14:39:46 -07:00
|
|
|
if (stat & (OMAP_I2C_STAT_ARDY | OMAP_I2C_STAT_NACK |
|
2009-07-21 09:14:40 -06:00
|
|
|
OMAP_I2C_STAT_AL)) {
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_ack_stat(omap, (OMAP_I2C_STAT_RRDY |
|
i2c: omap: simplify omap_i2c_ack_stat()
stat & BIT(1) is the same as BIT(1), so let's
simplify things a bit by removing "stat &" from
all omap_i2c_ack_stat() calls.
Code snippet (extremely simplified):
if (stat & NACK) {
...
omap_i2c_ack_stat(dev, stat & NACK);
}
if (stat & RDR) {
...
omap_i2c_ack_stat(dev, stat & RDR);
}
and so on. The tricky place is only WRT errata handling, for example:
if (*stat & (NACK | AL)) {
omap_i2c_ack_stat(dev, *stat & (XRDY | XDR));
...
}
but in this case, the errata says we must clear XRDY and XDR if that
errata triggers, so if they just got enabled or not, it doesn't matter.
Another tricky place is RDR | RRDY (likewise for XDR | XRDY):
if (stat & (RDR | RRDY)) {
...
omap_i2c_ack_stat(dev, stat & (RDR | RRDY));
}
again here there will be no issues because those IRQs never fire
simultaneously and one will only after after we have handled the
previous, that's because the same FIFO is used anyway and we won't shift
data into FIFO until we tell the IP "hey, I'm done with the FIFO, you
can shift more data"
Signed-off-by: Felipe Balbi <balbi@ti.com>
Reviewed-by : Santosh Shilimkar <santosh.shilimkar@ti.com>
[Added the explaination from the discurssion to the commit logs]
Signed-off-by: Shubhrajyoti D <shubhrajyoti@ti.com>
Signed-off-by: Wolfram Sang <w.sang@pengutronix.de>
2012-09-12 04:57:59 -06:00
|
|
|
OMAP_I2C_STAT_RDR |
|
|
|
|
OMAP_I2C_STAT_XRDY |
|
|
|
|
OMAP_I2C_STAT_XDR |
|
|
|
|
OMAP_I2C_STAT_ARDY));
|
2012-09-12 04:58:16 -06:00
|
|
|
break;
|
2009-07-21 09:14:40 -06:00
|
|
|
}
|
2012-09-12 04:57:58 -06:00
|
|
|
|
2012-09-12 04:58:00 -06:00
|
|
|
if (stat & OMAP_I2C_STAT_RDR) {
|
2008-11-21 14:39:46 -07:00
|
|
|
u8 num_bytes = 1;
|
2010-05-11 12:35:20 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->fifo_size)
|
|
|
|
num_bytes = omap->buf_len;
|
2012-09-12 04:58:00 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->errata & I2C_OMAP_ERRATA_I207) {
|
|
|
|
i2c_omap_errata_i207(omap, stat);
|
|
|
|
num_bytes = (omap_i2c_read_reg(omap,
|
2014-11-20 17:16:51 -07:00
|
|
|
OMAP_I2C_BUFSTAT_REG) >> 8) & 0x3F;
|
|
|
|
}
|
2010-05-11 12:35:20 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_receive_data(omap, num_bytes, true);
|
|
|
|
omap_i2c_ack_stat(omap, OMAP_I2C_STAT_RDR);
|
2013-01-20 11:37:02 -07:00
|
|
|
continue;
|
2012-09-12 04:58:00 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (stat & OMAP_I2C_STAT_RRDY) {
|
|
|
|
u8 num_bytes = 1;
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->threshold)
|
|
|
|
num_bytes = omap->threshold;
|
2012-09-12 04:58:00 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_receive_data(omap, num_bytes, false);
|
|
|
|
omap_i2c_ack_stat(omap, OMAP_I2C_STAT_RRDY);
|
2006-08-13 15:44:09 -06:00
|
|
|
continue;
|
|
|
|
}
|
2012-09-12 04:57:58 -06:00
|
|
|
|
2012-09-12 04:58:00 -06:00
|
|
|
if (stat & OMAP_I2C_STAT_XDR) {
|
2008-11-21 14:39:46 -07:00
|
|
|
u8 num_bytes = 1;
|
2012-09-12 04:58:02 -06:00
|
|
|
int ret;
|
2012-09-12 04:58:00 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->fifo_size)
|
|
|
|
num_bytes = omap->buf_len;
|
2012-09-12 04:58:00 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
ret = omap_i2c_transmit_data(omap, num_bytes, true);
|
2012-09-12 04:58:02 -06:00
|
|
|
if (ret < 0)
|
2012-09-12 04:58:16 -06:00
|
|
|
break;
|
2012-09-12 04:58:00 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_ack_stat(omap, OMAP_I2C_STAT_XDR);
|
2013-01-20 11:37:02 -07:00
|
|
|
continue;
|
2012-09-12 04:58:00 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (stat & OMAP_I2C_STAT_XRDY) {
|
|
|
|
u8 num_bytes = 1;
|
2012-09-12 04:58:02 -06:00
|
|
|
int ret;
|
2012-09-12 04:58:00 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->threshold)
|
|
|
|
num_bytes = omap->threshold;
|
2012-09-12 04:58:00 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
ret = omap_i2c_transmit_data(omap, num_bytes, false);
|
2012-09-12 04:58:02 -06:00
|
|
|
if (ret < 0)
|
2012-09-12 04:58:16 -06:00
|
|
|
break;
|
2012-09-12 04:58:00 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_ack_stat(omap, OMAP_I2C_STAT_XRDY);
|
2006-08-13 15:44:09 -06:00
|
|
|
continue;
|
|
|
|
}
|
2012-09-12 04:57:58 -06:00
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
if (stat & OMAP_I2C_STAT_ROVR) {
|
2015-07-13 14:38:03 -06:00
|
|
|
dev_err(omap->dev, "Receive overrun\n");
|
2012-09-12 04:58:04 -06:00
|
|
|
err |= OMAP_I2C_STAT_ROVR;
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_ack_stat(omap, OMAP_I2C_STAT_ROVR);
|
2012-09-12 04:58:16 -06:00
|
|
|
break;
|
2006-08-13 15:44:09 -06:00
|
|
|
}
|
2012-09-12 04:57:58 -06:00
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
if (stat & OMAP_I2C_STAT_XUDF) {
|
2015-07-13 14:38:03 -06:00
|
|
|
dev_err(omap->dev, "Transmit underflow\n");
|
2012-09-12 04:58:04 -06:00
|
|
|
err |= OMAP_I2C_STAT_XUDF;
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_ack_stat(omap, OMAP_I2C_STAT_XUDF);
|
2012-09-12 04:58:16 -06:00
|
|
|
break;
|
2006-08-13 15:44:09 -06:00
|
|
|
}
|
2012-09-12 04:58:03 -06:00
|
|
|
} while (stat);
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2019-04-03 06:40:13 -06:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static irqreturn_t
|
|
|
|
omap_i2c_isr_thread(int this_irq, void *dev_id)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct omap_i2c_dev *omap = dev_id;
|
|
|
|
|
|
|
|
ret = omap_i2c_xfer_data(omap);
|
|
|
|
if (ret != -EAGAIN)
|
|
|
|
omap_i2c_complete_cmd(omap, ret);
|
2012-09-12 04:58:16 -06:00
|
|
|
|
2012-09-12 04:58:08 -06:00
|
|
|
return IRQ_HANDLED;
|
2006-08-13 15:44:09 -06:00
|
|
|
}
|
|
|
|
|
2006-09-03 14:39:46 -06:00
|
|
|
static const struct i2c_algorithm omap_i2c_algo = {
|
2019-04-03 06:40:13 -06:00
|
|
|
.master_xfer = omap_i2c_xfer_irq,
|
|
|
|
.master_xfer_atomic = omap_i2c_xfer_polling,
|
2006-08-13 15:44:09 -06:00
|
|
|
.functionality = omap_i2c_func,
|
|
|
|
};
|
|
|
|
|
2018-07-23 14:26:08 -06:00
|
|
|
static const struct i2c_adapter_quirks omap_i2c_quirks = {
|
|
|
|
.flags = I2C_AQ_NO_ZERO_LEN,
|
|
|
|
};
|
|
|
|
|
2011-12-22 07:56:36 -07:00
|
|
|
#ifdef CONFIG_OF
|
2013-11-14 16:25:07 -07:00
|
|
|
static struct omap_i2c_bus_platform_data omap2420_pdata = {
|
|
|
|
.rev = OMAP_I2C_IP_VERSION_1,
|
|
|
|
.flags = OMAP_I2C_FLAG_NO_FIFO |
|
|
|
|
OMAP_I2C_FLAG_SIMPLE_CLOCK |
|
|
|
|
OMAP_I2C_FLAG_16BIT_DATA_REG |
|
|
|
|
OMAP_I2C_FLAG_BUS_SHIFT_2,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct omap_i2c_bus_platform_data omap2430_pdata = {
|
|
|
|
.rev = OMAP_I2C_IP_VERSION_1,
|
|
|
|
.flags = OMAP_I2C_FLAG_BUS_SHIFT_2 |
|
|
|
|
OMAP_I2C_FLAG_FORCE_19200_INT_CLK,
|
|
|
|
};
|
|
|
|
|
2011-12-22 07:56:36 -07:00
|
|
|
static struct omap_i2c_bus_platform_data omap3_pdata = {
|
|
|
|
.rev = OMAP_I2C_IP_VERSION_1,
|
2012-11-26 02:55:11 -07:00
|
|
|
.flags = OMAP_I2C_FLAG_BUS_SHIFT_2,
|
2011-12-22 07:56:36 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct omap_i2c_bus_platform_data omap4_pdata = {
|
|
|
|
.rev = OMAP_I2C_IP_VERSION_2,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct of_device_id omap_i2c_of_match[] = {
|
|
|
|
{
|
|
|
|
.compatible = "ti,omap4-i2c",
|
|
|
|
.data = &omap4_pdata,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.compatible = "ti,omap3-i2c",
|
|
|
|
.data = &omap3_pdata,
|
|
|
|
},
|
2013-11-14 16:25:07 -07:00
|
|
|
{
|
|
|
|
.compatible = "ti,omap2430-i2c",
|
|
|
|
.data = &omap2430_pdata,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.compatible = "ti,omap2420-i2c",
|
|
|
|
.data = &omap2420_pdata,
|
|
|
|
},
|
2011-12-22 07:56:36 -07:00
|
|
|
{ },
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(of, omap_i2c_of_match);
|
|
|
|
#endif
|
|
|
|
|
2012-11-05 05:23:36 -07:00
|
|
|
#define OMAP_I2C_SCHEME(rev) ((rev & 0xc000) >> 14)
|
|
|
|
|
|
|
|
#define OMAP_I2C_REV_SCHEME_0_MAJOR(rev) (rev >> 4)
|
|
|
|
#define OMAP_I2C_REV_SCHEME_0_MINOR(rev) (rev & 0xf)
|
|
|
|
|
|
|
|
#define OMAP_I2C_REV_SCHEME_1_MAJOR(rev) ((rev & 0x0700) >> 7)
|
|
|
|
#define OMAP_I2C_REV_SCHEME_1_MINOR(rev) (rev & 0x1f)
|
|
|
|
#define OMAP_I2C_SCHEME_0 0
|
|
|
|
#define OMAP_I2C_SCHEME_1 1
|
|
|
|
|
2015-05-06 10:50:27 -06:00
|
|
|
static int omap_i2c_get_scl(struct i2c_adapter *adap)
|
|
|
|
{
|
|
|
|
struct omap_i2c_dev *dev = i2c_get_adapdata(adap);
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
reg = omap_i2c_read_reg(dev, OMAP_I2C_SYSTEST_REG);
|
|
|
|
|
|
|
|
return reg & OMAP_I2C_SYSTEST_SCL_I_FUNC;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int omap_i2c_get_sda(struct i2c_adapter *adap)
|
|
|
|
{
|
|
|
|
struct omap_i2c_dev *dev = i2c_get_adapdata(adap);
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
reg = omap_i2c_read_reg(dev, OMAP_I2C_SYSTEST_REG);
|
|
|
|
|
|
|
|
return reg & OMAP_I2C_SYSTEST_SDA_I_FUNC;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void omap_i2c_set_scl(struct i2c_adapter *adap, int val)
|
|
|
|
{
|
|
|
|
struct omap_i2c_dev *dev = i2c_get_adapdata(adap);
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
reg = omap_i2c_read_reg(dev, OMAP_I2C_SYSTEST_REG);
|
|
|
|
if (val)
|
|
|
|
reg |= OMAP_I2C_SYSTEST_SCL_O;
|
|
|
|
else
|
|
|
|
reg &= ~OMAP_I2C_SYSTEST_SCL_O;
|
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_SYSTEST_REG, reg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void omap_i2c_prepare_recovery(struct i2c_adapter *adap)
|
|
|
|
{
|
|
|
|
struct omap_i2c_dev *dev = i2c_get_adapdata(adap);
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
reg = omap_i2c_read_reg(dev, OMAP_I2C_SYSTEST_REG);
|
2015-07-08 08:35:27 -06:00
|
|
|
/* enable test mode */
|
2015-05-06 10:50:27 -06:00
|
|
|
reg |= OMAP_I2C_SYSTEST_ST_EN;
|
2015-07-08 08:35:27 -06:00
|
|
|
/* select SDA/SCL IO mode */
|
|
|
|
reg |= 3 << OMAP_I2C_SYSTEST_TMODE_SHIFT;
|
|
|
|
/* set SCL to high-impedance state (reset value is 0) */
|
|
|
|
reg |= OMAP_I2C_SYSTEST_SCL_O;
|
|
|
|
/* set SDA to high-impedance state (reset value is 0) */
|
|
|
|
reg |= OMAP_I2C_SYSTEST_SDA_O;
|
2015-05-06 10:50:27 -06:00
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_SYSTEST_REG, reg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void omap_i2c_unprepare_recovery(struct i2c_adapter *adap)
|
|
|
|
{
|
|
|
|
struct omap_i2c_dev *dev = i2c_get_adapdata(adap);
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
reg = omap_i2c_read_reg(dev, OMAP_I2C_SYSTEST_REG);
|
2015-07-08 08:35:27 -06:00
|
|
|
/* restore reset values */
|
2015-05-06 10:50:27 -06:00
|
|
|
reg &= ~OMAP_I2C_SYSTEST_ST_EN;
|
2015-07-08 08:35:27 -06:00
|
|
|
reg &= ~OMAP_I2C_SYSTEST_TMODE_MASK;
|
|
|
|
reg &= ~OMAP_I2C_SYSTEST_SCL_O;
|
|
|
|
reg &= ~OMAP_I2C_SYSTEST_SDA_O;
|
2015-05-06 10:50:27 -06:00
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_SYSTEST_REG, reg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct i2c_bus_recovery_info omap_i2c_bus_recovery_info = {
|
|
|
|
.get_scl = omap_i2c_get_scl,
|
|
|
|
.get_sda = omap_i2c_get_sda,
|
|
|
|
.set_scl = omap_i2c_set_scl,
|
|
|
|
.prepare_recovery = omap_i2c_prepare_recovery,
|
|
|
|
.unprepare_recovery = omap_i2c_unprepare_recovery,
|
|
|
|
.recover_bus = i2c_generic_scl_recovery,
|
|
|
|
};
|
|
|
|
|
2012-11-27 13:59:38 -07:00
|
|
|
static int
|
2006-08-13 15:44:09 -06:00
|
|
|
omap_i2c_probe(struct platform_device *pdev)
|
|
|
|
{
|
2015-07-13 14:38:03 -06:00
|
|
|
struct omap_i2c_dev *omap;
|
2006-08-13 15:44:09 -06:00
|
|
|
struct i2c_adapter *adap;
|
2012-09-12 04:58:05 -06:00
|
|
|
struct resource *mem;
|
2012-05-21 13:57:39 -06:00
|
|
|
const struct omap_i2c_bus_platform_data *pdata =
|
2013-07-30 01:59:33 -06:00
|
|
|
dev_get_platdata(&pdev->dev);
|
2011-12-22 07:56:36 -07:00
|
|
|
struct device_node *node = pdev->dev.of_node;
|
|
|
|
const struct of_device_id *match;
|
2012-09-12 04:58:05 -06:00
|
|
|
int irq;
|
2006-08-13 15:44:09 -06:00
|
|
|
int r;
|
2012-11-05 05:23:36 -07:00
|
|
|
u32 rev;
|
2013-06-03 01:37:20 -06:00
|
|
|
u16 minor, major;
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2012-09-12 04:58:05 -06:00
|
|
|
irq = platform_get_irq(pdev, 0);
|
|
|
|
if (irq < 0) {
|
2006-08-13 15:44:09 -06:00
|
|
|
dev_err(&pdev->dev, "no irq resource?\n");
|
2012-09-12 04:58:05 -06:00
|
|
|
return irq;
|
2006-08-13 15:44:09 -06:00
|
|
|
}
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
omap = devm_kzalloc(&pdev->dev, sizeof(struct omap_i2c_dev), GFP_KERNEL);
|
|
|
|
if (!omap)
|
2012-09-12 04:57:55 -06:00
|
|
|
return -ENOMEM;
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2013-05-10 02:16:54 -06:00
|
|
|
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
2015-07-13 14:38:03 -06:00
|
|
|
omap->base = devm_ioremap_resource(&pdev->dev, mem);
|
|
|
|
if (IS_ERR(omap->base))
|
|
|
|
return PTR_ERR(omap->base);
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2012-01-20 08:55:04 -07:00
|
|
|
match = of_match_device(of_match_ptr(omap_i2c_of_match), &pdev->dev);
|
2011-12-22 07:56:36 -07:00
|
|
|
if (match) {
|
|
|
|
u32 freq = 100000; /* default to 100000 Hz */
|
|
|
|
|
|
|
|
pdata = match->data;
|
2015-07-13 14:38:03 -06:00
|
|
|
omap->flags = pdata->flags;
|
2011-12-22 07:56:36 -07:00
|
|
|
|
|
|
|
of_property_read_u32(node, "clock-frequency", &freq);
|
|
|
|
/* convert DT freq value in Hz into kHz for speed */
|
2015-07-13 14:38:03 -06:00
|
|
|
omap->speed = freq / 1000;
|
2011-12-22 07:56:36 -07:00
|
|
|
} else if (pdata != NULL) {
|
2015-07-13 14:38:03 -06:00
|
|
|
omap->speed = pdata->clkrate;
|
|
|
|
omap->flags = pdata->flags;
|
|
|
|
omap->set_mpu_wkup_lat = pdata->set_mpu_wkup_lat;
|
2010-05-11 12:35:08 -06:00
|
|
|
}
|
2008-11-21 14:39:45 -07:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
omap->dev = &pdev->dev;
|
|
|
|
omap->irq = irq;
|
2008-09-04 07:07:22 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
platform_set_drvdata(pdev, omap);
|
|
|
|
init_completion(&omap->cmd_complete);
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
omap->reg_shift = (omap->flags >> OMAP_I2C_FLAG_BUS_SHIFT__SHIFT) & 3;
|
2010-03-23 04:12:56 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
pm_runtime_enable(omap->dev);
|
|
|
|
pm_runtime_set_autosuspend_delay(omap->dev, OMAP_I2C_PM_TIMEOUT);
|
|
|
|
pm_runtime_use_autosuspend(omap->dev);
|
2012-09-12 04:58:15 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
r = pm_runtime_get_sync(omap->dev);
|
2015-07-14 06:07:08 -06:00
|
|
|
if (r < 0)
|
2012-05-29 04:56:19 -06:00
|
|
|
goto err_free_mem;
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2012-11-05 05:23:36 -07:00
|
|
|
/*
|
|
|
|
* Read the Rev hi bit-[15:14] ie scheme this is 1 indicates ver2.
|
|
|
|
* On omap1/3/2 Offset 4 is IE Reg the bit [15:14] is 0 at reset.
|
|
|
|
* Also since the omap_i2c_read_reg uses reg_map_ip_* a
|
2013-11-27 06:48:08 -07:00
|
|
|
* readw_relaxed is done.
|
2012-11-05 05:23:36 -07:00
|
|
|
*/
|
2015-07-13 14:38:03 -06:00
|
|
|
rev = readw_relaxed(omap->base + 0x04);
|
2012-11-05 05:23:36 -07:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
omap->scheme = OMAP_I2C_SCHEME(rev);
|
|
|
|
switch (omap->scheme) {
|
2012-11-05 05:23:36 -07:00
|
|
|
case OMAP_I2C_SCHEME_0:
|
2015-07-13 14:38:03 -06:00
|
|
|
omap->regs = (u8 *)reg_map_ip_v1;
|
|
|
|
omap->rev = omap_i2c_read_reg(omap, OMAP_I2C_REV_REG);
|
|
|
|
minor = OMAP_I2C_REV_SCHEME_0_MAJOR(omap->rev);
|
|
|
|
major = OMAP_I2C_REV_SCHEME_0_MAJOR(omap->rev);
|
2012-11-05 05:23:36 -07:00
|
|
|
break;
|
|
|
|
case OMAP_I2C_SCHEME_1:
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
default:
|
2015-07-13 14:38:03 -06:00
|
|
|
omap->regs = (u8 *)reg_map_ip_v2;
|
2012-11-05 05:23:36 -07:00
|
|
|
rev = (rev << 16) |
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_read_reg(omap, OMAP_I2C_IP_V2_REVNB_LO);
|
2012-11-05 05:23:36 -07:00
|
|
|
minor = OMAP_I2C_REV_SCHEME_1_MINOR(rev);
|
|
|
|
major = OMAP_I2C_REV_SCHEME_1_MAJOR(rev);
|
2015-07-13 14:38:03 -06:00
|
|
|
omap->rev = rev;
|
2012-11-05 05:23:36 -07:00
|
|
|
}
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
omap->errata = 0;
|
2012-05-29 04:56:20 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->rev >= OMAP_I2C_REV_ON_2430 &&
|
|
|
|
omap->rev < OMAP_I2C_REV_ON_4430_PLUS)
|
|
|
|
omap->errata |= I2C_OMAP_ERRATA_I207;
|
2012-05-29 04:56:20 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->rev <= OMAP_I2C_REV_ON_3430_3530)
|
|
|
|
omap->errata |= I2C_OMAP_ERRATA_I462;
|
2010-05-11 12:35:23 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (!(omap->flags & OMAP_I2C_FLAG_NO_FIFO)) {
|
2008-11-21 14:39:46 -07:00
|
|
|
u16 s;
|
|
|
|
|
|
|
|
/* Set up the fifo size - Get total size */
|
2015-07-13 14:38:03 -06:00
|
|
|
s = (omap_i2c_read_reg(omap, OMAP_I2C_BUFSTAT_REG) >> 14) & 0x3;
|
|
|
|
omap->fifo_size = 0x8 << s;
|
2008-11-21 14:39:46 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Set up notification threshold as half the total available
|
|
|
|
* size. This is to ensure that we can handle the status on int
|
|
|
|
* call back latencies.
|
|
|
|
*/
|
2011-12-06 11:25:58 -07:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
omap->fifo_size = (omap->fifo_size / 2);
|
2011-12-06 11:25:58 -07:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->rev < OMAP_I2C_REV_ON_3630)
|
|
|
|
omap->b_hw = 1; /* Enable hardware fixes */
|
2011-12-06 11:25:58 -07:00
|
|
|
|
2010-05-11 12:35:08 -06:00
|
|
|
/* calculate wakeup latency constraint for MPU */
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->set_mpu_wkup_lat != NULL)
|
|
|
|
omap->latency = (1000000 * omap->fifo_size) /
|
|
|
|
(1000 * omap->speed / 8);
|
2008-11-21 14:39:46 -07:00
|
|
|
}
|
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
/* reset ASAP, clearing any IRQs */
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_init(omap);
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->rev < OMAP_I2C_OMAP1_REV_2)
|
|
|
|
r = devm_request_irq(&pdev->dev, omap->irq, omap_i2c_omap1_isr,
|
|
|
|
IRQF_NO_SUSPEND, pdev->name, omap);
|
2012-09-12 04:58:13 -06:00
|
|
|
else
|
2015-07-13 14:38:03 -06:00
|
|
|
r = devm_request_threaded_irq(&pdev->dev, omap->irq,
|
2012-09-12 04:58:13 -06:00
|
|
|
omap_i2c_isr, omap_i2c_isr_thread,
|
|
|
|
IRQF_NO_SUSPEND | IRQF_ONESHOT,
|
2015-07-13 14:38:03 -06:00
|
|
|
pdev->name, omap);
|
2006-08-13 15:44:09 -06:00
|
|
|
|
|
|
|
if (r) {
|
2015-07-13 14:38:03 -06:00
|
|
|
dev_err(omap->dev, "failure requesting irq %i\n", omap->irq);
|
2006-08-13 15:44:09 -06:00
|
|
|
goto err_unuse_clocks;
|
|
|
|
}
|
2008-11-21 14:39:55 -07:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
adap = &omap->adapter;
|
|
|
|
i2c_set_adapdata(adap, omap);
|
2006-08-13 15:44:09 -06:00
|
|
|
adap->owner = THIS_MODULE;
|
2014-07-10 05:46:30 -06:00
|
|
|
adap->class = I2C_CLASS_DEPRECATED;
|
2009-07-17 07:24:00 -06:00
|
|
|
strlcpy(adap->name, "OMAP I2C adapter", sizeof(adap->name));
|
2006-08-13 15:44:09 -06:00
|
|
|
adap->algo = &omap_i2c_algo;
|
2018-07-23 14:26:08 -06:00
|
|
|
adap->quirks = &omap_i2c_quirks;
|
2006-08-13 15:44:09 -06:00
|
|
|
adap->dev.parent = &pdev->dev;
|
2011-12-22 07:56:36 -07:00
|
|
|
adap->dev.of_node = pdev->dev.of_node;
|
2015-05-06 10:50:27 -06:00
|
|
|
adap->bus_recovery_info = &omap_i2c_bus_recovery_info;
|
2006-08-13 15:44:09 -06:00
|
|
|
|
|
|
|
/* i2c device drivers may be active on return from add_adapter() */
|
2007-05-01 15:26:32 -06:00
|
|
|
adap->nr = pdev->id;
|
|
|
|
r = i2c_add_numbered_adapter(adap);
|
2016-08-09 05:36:17 -06:00
|
|
|
if (r)
|
2012-09-12 04:57:55 -06:00
|
|
|
goto err_unuse_clocks;
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
dev_info(omap->dev, "bus %d rev%d.%d at %d kHz\n", adap->nr,
|
|
|
|
major, minor, omap->speed);
|
2012-08-31 05:02:55 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
pm_runtime_mark_last_busy(omap->dev);
|
|
|
|
pm_runtime_put_autosuspend(omap->dev);
|
2012-05-29 04:56:16 -06:00
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_unuse_clocks:
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_CON_REG, 0);
|
2016-02-10 16:02:45 -07:00
|
|
|
pm_runtime_dont_use_autosuspend(omap->dev);
|
|
|
|
pm_runtime_put_sync(omap->dev);
|
2012-05-29 04:56:14 -06:00
|
|
|
pm_runtime_disable(&pdev->dev);
|
2006-08-13 15:44:09 -06:00
|
|
|
err_free_mem:
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2012-11-27 13:59:38 -07:00
|
|
|
static int omap_i2c_remove(struct platform_device *pdev)
|
2006-08-13 15:44:09 -06:00
|
|
|
{
|
2015-07-13 14:38:03 -06:00
|
|
|
struct omap_i2c_dev *omap = platform_get_drvdata(pdev);
|
2012-05-29 04:56:19 -06:00
|
|
|
int ret;
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
i2c_del_adapter(&omap->adapter);
|
2012-05-29 04:56:19 -06:00
|
|
|
ret = pm_runtime_get_sync(&pdev->dev);
|
2014-03-27 10:18:33 -06:00
|
|
|
if (ret < 0)
|
2012-05-29 04:56:19 -06:00
|
|
|
return ret;
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_CON_REG, 0);
|
2016-02-10 16:02:45 -07:00
|
|
|
pm_runtime_dont_use_autosuspend(&pdev->dev);
|
2015-07-13 14:38:04 -06:00
|
|
|
pm_runtime_put_sync(&pdev->dev);
|
2012-05-29 04:56:14 -06:00
|
|
|
pm_runtime_disable(&pdev->dev);
|
2006-08-13 15:44:09 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-01-10 08:59:16 -07:00
|
|
|
static int __maybe_unused omap_i2c_runtime_suspend(struct device *dev)
|
2011-05-17 08:31:38 -06:00
|
|
|
{
|
2015-07-13 14:38:03 -06:00
|
|
|
struct omap_i2c_dev *omap = dev_get_drvdata(dev);
|
2012-05-29 04:56:13 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
omap->iestate = omap_i2c_read_reg(omap, OMAP_I2C_IE_REG);
|
2012-05-29 04:56:15 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->scheme == OMAP_I2C_SCHEME_0)
|
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_IE_REG, 0);
|
2013-06-03 01:37:20 -06:00
|
|
|
else
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_IP_V2_IRQENABLE_CLR,
|
2013-06-03 01:37:20 -06:00
|
|
|
OMAP_I2C_IP_V2_INTERRUPTS_MASK);
|
2011-05-17 08:31:38 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (omap->rev < OMAP_I2C_OMAP1_REV_2) {
|
|
|
|
omap_i2c_read_reg(omap, OMAP_I2C_IV_REG); /* Read clears */
|
2012-05-29 04:56:13 -06:00
|
|
|
} else {
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_write_reg(omap, OMAP_I2C_STAT_REG, omap->iestate);
|
2011-05-17 08:31:38 -06:00
|
|
|
|
2012-05-29 04:56:13 -06:00
|
|
|
/* Flush posted write */
|
2015-07-13 14:38:03 -06:00
|
|
|
omap_i2c_read_reg(omap, OMAP_I2C_STAT_REG);
|
2012-05-29 04:56:13 -06:00
|
|
|
}
|
2011-05-17 08:31:38 -06:00
|
|
|
|
2015-05-06 07:07:04 -06:00
|
|
|
pinctrl_pm_select_sleep_state(dev);
|
|
|
|
|
2011-05-17 08:31:38 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-01-10 08:59:16 -07:00
|
|
|
static int __maybe_unused omap_i2c_runtime_resume(struct device *dev)
|
2011-05-17 08:31:38 -06:00
|
|
|
{
|
2015-07-13 14:38:03 -06:00
|
|
|
struct omap_i2c_dev *omap = dev_get_drvdata(dev);
|
2015-05-06 07:07:04 -06:00
|
|
|
|
|
|
|
pinctrl_pm_select_default_state(dev);
|
2011-05-17 08:31:38 -06:00
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
if (!omap->regs)
|
2012-11-05 05:23:36 -07:00
|
|
|
return 0;
|
|
|
|
|
2015-07-13 14:38:03 -06:00
|
|
|
__omap_i2c_init(omap);
|
2011-05-17 08:31:38 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-01-15 02:59:41 -07:00
|
|
|
static const struct dev_pm_ops omap_i2c_pm_ops = {
|
2019-01-10 08:59:16 -07:00
|
|
|
SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
|
|
|
|
pm_runtime_force_resume)
|
2012-06-28 09:11:28 -06:00
|
|
|
SET_RUNTIME_PM_OPS(omap_i2c_runtime_suspend,
|
|
|
|
omap_i2c_runtime_resume, NULL)
|
2011-05-17 08:31:38 -06:00
|
|
|
};
|
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
static struct platform_driver omap_i2c_driver = {
|
|
|
|
.probe = omap_i2c_probe,
|
2012-11-27 13:59:38 -07:00
|
|
|
.remove = omap_i2c_remove,
|
2006-08-13 15:44:09 -06:00
|
|
|
.driver = {
|
2010-12-09 07:24:16 -07:00
|
|
|
.name = "omap_i2c",
|
2019-01-10 08:59:16 -07:00
|
|
|
.pm = &omap_i2c_pm_ops,
|
2011-12-22 07:56:36 -07:00
|
|
|
.of_match_table = of_match_ptr(omap_i2c_of_match),
|
2006-08-13 15:44:09 -06:00
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
/* I2C may be needed to bring up other drivers */
|
|
|
|
static int __init
|
|
|
|
omap_i2c_init_driver(void)
|
|
|
|
{
|
|
|
|
return platform_driver_register(&omap_i2c_driver);
|
|
|
|
}
|
|
|
|
subsys_initcall(omap_i2c_init_driver);
|
|
|
|
|
|
|
|
static void __exit omap_i2c_exit_driver(void)
|
|
|
|
{
|
|
|
|
platform_driver_unregister(&omap_i2c_driver);
|
|
|
|
}
|
|
|
|
module_exit(omap_i2c_exit_driver);
|
|
|
|
|
|
|
|
MODULE_AUTHOR("MontaVista Software, Inc. (and others)");
|
|
|
|
MODULE_DESCRIPTION("TI OMAP I2C bus adapter");
|
|
|
|
MODULE_LICENSE("GPL");
|
2010-12-09 07:24:16 -07:00
|
|
|
MODULE_ALIAS("platform:omap_i2c");
|