2006-12-10 21:21:29 +01:00
|
|
|
/*
|
|
|
|
* Provides I2C support for Philips PNX010x/PNX4008 boards.
|
|
|
|
*
|
|
|
|
* Authors: Dennis Kovalev <dkovalev@ru.mvista.com>
|
|
|
|
* Vitaly Wool <vwool@ru.mvista.com>
|
|
|
|
*
|
|
|
|
* 2004-2006 (c) MontaVista Software, Inc. This file is licensed under
|
|
|
|
* the terms of the GNU General Public License version 2. This program
|
|
|
|
* is licensed "as is" without any warranty of any kind, whether express
|
|
|
|
* or implied.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/ioport.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/i2c.h>
|
|
|
|
#include <linux/timer.h>
|
|
|
|
#include <linux/completion.h>
|
|
|
|
#include <linux/platform_device.h>
|
2009-11-12 00:25:52 +01:00
|
|
|
#include <linux/io.h>
|
2009-11-20 12:12:26 +01:00
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/clk.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 09:04:11 +01:00
|
|
|
#include <linux/slab.h>
|
2013-10-16 11:56:33 +02:00
|
|
|
#include <linux/of.h>
|
2009-11-20 12:12:26 +01:00
|
|
|
|
2012-04-22 11:59:47 +02:00
|
|
|
#define I2C_PNX_TIMEOUT_DEFAULT 10 /* msec */
|
|
|
|
#define I2C_PNX_SPEED_KHZ_DEFAULT 100
|
|
|
|
#define I2C_PNX_REGION_SIZE 0x100
|
2006-12-10 21:21:29 +01:00
|
|
|
|
2018-04-19 22:00:13 +02:00
|
|
|
struct i2c_pnx_mif {
|
|
|
|
int ret; /* Return value */
|
|
|
|
int mode; /* Interface mode */
|
|
|
|
struct completion complete; /* I/O completion */
|
|
|
|
struct timer_list timer; /* Timeout */
|
|
|
|
u8 * buf; /* Data buffer */
|
|
|
|
int len; /* Length of data buffer */
|
|
|
|
int order; /* RX Bytes to order via TX */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct i2c_pnx_algo_data {
|
|
|
|
void __iomem *ioaddr;
|
|
|
|
struct i2c_pnx_mif mif;
|
|
|
|
int last;
|
|
|
|
struct clk *clk;
|
|
|
|
struct i2c_adapter adapter;
|
|
|
|
int irq;
|
|
|
|
u32 timeout;
|
|
|
|
};
|
|
|
|
|
2012-04-22 11:59:47 +02:00
|
|
|
enum {
|
|
|
|
mstatus_tdi = 0x00000001,
|
|
|
|
mstatus_afi = 0x00000002,
|
|
|
|
mstatus_nai = 0x00000004,
|
|
|
|
mstatus_drmi = 0x00000008,
|
|
|
|
mstatus_active = 0x00000020,
|
|
|
|
mstatus_scl = 0x00000040,
|
|
|
|
mstatus_sda = 0x00000080,
|
|
|
|
mstatus_rff = 0x00000100,
|
|
|
|
mstatus_rfe = 0x00000200,
|
|
|
|
mstatus_tff = 0x00000400,
|
|
|
|
mstatus_tfe = 0x00000800,
|
|
|
|
};
|
|
|
|
|
|
|
|
enum {
|
|
|
|
mcntrl_tdie = 0x00000001,
|
|
|
|
mcntrl_afie = 0x00000002,
|
|
|
|
mcntrl_naie = 0x00000004,
|
|
|
|
mcntrl_drmie = 0x00000008,
|
2012-08-08 09:42:31 +02:00
|
|
|
mcntrl_drsie = 0x00000010,
|
|
|
|
mcntrl_rffie = 0x00000020,
|
|
|
|
mcntrl_daie = 0x00000040,
|
2012-04-22 11:59:47 +02:00
|
|
|
mcntrl_tffie = 0x00000080,
|
|
|
|
mcntrl_reset = 0x00000100,
|
|
|
|
mcntrl_cdbmode = 0x00000400,
|
|
|
|
};
|
|
|
|
|
|
|
|
enum {
|
|
|
|
rw_bit = 1 << 0,
|
|
|
|
start_bit = 1 << 8,
|
|
|
|
stop_bit = 1 << 9,
|
|
|
|
};
|
|
|
|
|
|
|
|
#define I2C_REG_RX(a) ((a)->ioaddr) /* Rx FIFO reg (RO) */
|
|
|
|
#define I2C_REG_TX(a) ((a)->ioaddr) /* Tx FIFO reg (WO) */
|
|
|
|
#define I2C_REG_STS(a) ((a)->ioaddr + 0x04) /* Status reg (RO) */
|
|
|
|
#define I2C_REG_CTL(a) ((a)->ioaddr + 0x08) /* Ctl reg */
|
|
|
|
#define I2C_REG_CKL(a) ((a)->ioaddr + 0x0c) /* Clock divider low */
|
|
|
|
#define I2C_REG_CKH(a) ((a)->ioaddr + 0x10) /* Clock divider high */
|
|
|
|
#define I2C_REG_ADR(a) ((a)->ioaddr + 0x14) /* I2C address */
|
|
|
|
#define I2C_REG_RFL(a) ((a)->ioaddr + 0x18) /* Rx FIFO level (RO) */
|
|
|
|
#define I2C_REG_TFL(a) ((a)->ioaddr + 0x1c) /* Tx FIFO level (RO) */
|
|
|
|
#define I2C_REG_RXB(a) ((a)->ioaddr + 0x20) /* Num of bytes Rx-ed (RO) */
|
|
|
|
#define I2C_REG_TXB(a) ((a)->ioaddr + 0x24) /* Num of bytes Tx-ed (RO) */
|
|
|
|
#define I2C_REG_TXS(a) ((a)->ioaddr + 0x28) /* Tx slave FIFO (RO) */
|
|
|
|
#define I2C_REG_STFL(a) ((a)->ioaddr + 0x2c) /* Tx slave FIFO level (RO) */
|
|
|
|
|
2012-04-22 11:59:47 +02:00
|
|
|
static inline int wait_timeout(struct i2c_pnx_algo_data *data)
|
2006-12-10 21:21:29 +01:00
|
|
|
{
|
2012-04-22 11:59:47 +02:00
|
|
|
long timeout = data->timeout;
|
2006-12-10 21:21:29 +01:00
|
|
|
while (timeout > 0 &&
|
|
|
|
(ioread32(I2C_REG_STS(data)) & mstatus_active)) {
|
|
|
|
mdelay(1);
|
|
|
|
timeout--;
|
|
|
|
}
|
|
|
|
return (timeout <= 0);
|
|
|
|
}
|
|
|
|
|
2012-04-22 11:59:47 +02:00
|
|
|
static inline int wait_reset(struct i2c_pnx_algo_data *data)
|
2006-12-10 21:21:29 +01:00
|
|
|
{
|
2012-04-22 11:59:47 +02:00
|
|
|
long timeout = data->timeout;
|
2006-12-10 21:21:29 +01:00
|
|
|
while (timeout > 0 &&
|
|
|
|
(ioread32(I2C_REG_CTL(data)) & mcntrl_reset)) {
|
|
|
|
mdelay(1);
|
|
|
|
timeout--;
|
|
|
|
}
|
|
|
|
return (timeout <= 0);
|
|
|
|
}
|
|
|
|
|
2009-11-21 13:40:00 +01:00
|
|
|
static inline void i2c_pnx_arm_timer(struct i2c_pnx_algo_data *alg_data)
|
2006-12-10 21:21:29 +01:00
|
|
|
{
|
2009-11-21 13:40:00 +01:00
|
|
|
struct timer_list *timer = &alg_data->mif.timer;
|
2012-04-22 11:59:47 +02:00
|
|
|
unsigned long expires = msecs_to_jiffies(alg_data->timeout);
|
2006-12-10 21:21:29 +01:00
|
|
|
|
2009-11-12 00:28:13 +01:00
|
|
|
if (expires <= 1)
|
|
|
|
expires = 2;
|
|
|
|
|
2006-12-10 21:21:29 +01:00
|
|
|
del_timer_sync(timer);
|
|
|
|
|
2009-11-21 13:58:13 +01:00
|
|
|
dev_dbg(&alg_data->adapter.dev, "Timer armed at %lu plus %lu jiffies.\n",
|
2006-12-10 21:21:29 +01:00
|
|
|
jiffies, expires);
|
|
|
|
|
|
|
|
timer->expires = jiffies + expires;
|
|
|
|
|
|
|
|
add_timer(timer);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* i2c_pnx_start - start a device
|
|
|
|
* @slave_addr: slave address
|
|
|
|
* @adap: pointer to adapter structure
|
|
|
|
*
|
|
|
|
* Generate a START signal in the desired mode.
|
|
|
|
*/
|
2009-11-21 13:40:00 +01:00
|
|
|
static int i2c_pnx_start(unsigned char slave_addr,
|
|
|
|
struct i2c_pnx_algo_data *alg_data)
|
2006-12-10 21:21:29 +01:00
|
|
|
{
|
2009-11-21 13:40:00 +01:00
|
|
|
dev_dbg(&alg_data->adapter.dev, "%s(): addr 0x%x mode %d\n", __func__,
|
2006-12-10 21:21:29 +01:00
|
|
|
slave_addr, alg_data->mif.mode);
|
|
|
|
|
|
|
|
/* Check for 7 bit slave addresses only */
|
|
|
|
if (slave_addr & ~0x7f) {
|
2009-11-21 13:46:31 +01:00
|
|
|
dev_err(&alg_data->adapter.dev,
|
|
|
|
"%s: Invalid slave address %x. Only 7-bit addresses are supported\n",
|
|
|
|
alg_data->adapter.name, slave_addr);
|
2006-12-10 21:21:29 +01:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* First, make sure bus is idle */
|
2012-04-22 11:59:47 +02:00
|
|
|
if (wait_timeout(alg_data)) {
|
2006-12-10 21:21:29 +01:00
|
|
|
/* Somebody else is monopolizing the bus */
|
2009-11-21 13:46:31 +01:00
|
|
|
dev_err(&alg_data->adapter.dev,
|
|
|
|
"%s: Bus busy. Slave addr = %02x, cntrl = %x, stat = %x\n",
|
|
|
|
alg_data->adapter.name, slave_addr,
|
|
|
|
ioread32(I2C_REG_CTL(alg_data)),
|
|
|
|
ioread32(I2C_REG_STS(alg_data)));
|
2006-12-10 21:21:29 +01:00
|
|
|
return -EBUSY;
|
|
|
|
} else if (ioread32(I2C_REG_STS(alg_data)) & mstatus_afi) {
|
|
|
|
/* Sorry, we lost the bus */
|
2009-11-21 13:46:31 +01:00
|
|
|
dev_err(&alg_data->adapter.dev,
|
|
|
|
"%s: Arbitration failure. Slave addr = %02x\n",
|
|
|
|
alg_data->adapter.name, slave_addr);
|
2006-12-10 21:21:29 +01:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* OK, I2C is enabled and we have the bus.
|
|
|
|
* Clear the current TDI and AFI status flags.
|
|
|
|
*/
|
|
|
|
iowrite32(ioread32(I2C_REG_STS(alg_data)) | mstatus_tdi | mstatus_afi,
|
|
|
|
I2C_REG_STS(alg_data));
|
|
|
|
|
2009-11-21 13:40:00 +01:00
|
|
|
dev_dbg(&alg_data->adapter.dev, "%s(): sending %#x\n", __func__,
|
2006-12-10 21:21:29 +01:00
|
|
|
(slave_addr << 1) | start_bit | alg_data->mif.mode);
|
|
|
|
|
|
|
|
/* Write the slave address, START bit and R/W bit */
|
|
|
|
iowrite32((slave_addr << 1) | start_bit | alg_data->mif.mode,
|
|
|
|
I2C_REG_TX(alg_data));
|
|
|
|
|
2009-11-21 13:40:00 +01:00
|
|
|
dev_dbg(&alg_data->adapter.dev, "%s(): exit\n", __func__);
|
2006-12-10 21:21:29 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* i2c_pnx_stop - stop a device
|
|
|
|
* @adap: pointer to I2C adapter structure
|
|
|
|
*
|
|
|
|
* Generate a STOP signal to terminate the master transaction.
|
|
|
|
*/
|
2009-11-21 13:40:00 +01:00
|
|
|
static void i2c_pnx_stop(struct i2c_pnx_algo_data *alg_data)
|
2006-12-10 21:21:29 +01:00
|
|
|
{
|
|
|
|
/* Only 1 msec max timeout due to interrupt context */
|
|
|
|
long timeout = 1000;
|
|
|
|
|
2009-11-21 13:40:00 +01:00
|
|
|
dev_dbg(&alg_data->adapter.dev, "%s(): entering: stat = %04x.\n",
|
2008-04-22 22:16:47 +02:00
|
|
|
__func__, ioread32(I2C_REG_STS(alg_data)));
|
2006-12-10 21:21:29 +01:00
|
|
|
|
|
|
|
/* Write a STOP bit to TX FIFO */
|
|
|
|
iowrite32(0xff | stop_bit, I2C_REG_TX(alg_data));
|
|
|
|
|
|
|
|
/* Wait until the STOP is seen. */
|
|
|
|
while (timeout > 0 &&
|
|
|
|
(ioread32(I2C_REG_STS(alg_data)) & mstatus_active)) {
|
|
|
|
/* may be called from interrupt context */
|
|
|
|
udelay(1);
|
|
|
|
timeout--;
|
|
|
|
}
|
|
|
|
|
2009-11-21 13:40:00 +01:00
|
|
|
dev_dbg(&alg_data->adapter.dev, "%s(): exiting: stat = %04x.\n",
|
2008-04-22 22:16:47 +02:00
|
|
|
__func__, ioread32(I2C_REG_STS(alg_data)));
|
2006-12-10 21:21:29 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* i2c_pnx_master_xmit - transmit data to slave
|
|
|
|
* @adap: pointer to I2C adapter structure
|
|
|
|
*
|
|
|
|
* Sends one byte of data to the slave
|
|
|
|
*/
|
2009-11-21 13:40:00 +01:00
|
|
|
static int i2c_pnx_master_xmit(struct i2c_pnx_algo_data *alg_data)
|
2006-12-10 21:21:29 +01:00
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
|
2009-11-21 13:40:00 +01:00
|
|
|
dev_dbg(&alg_data->adapter.dev, "%s(): entering: stat = %04x.\n",
|
2008-04-22 22:16:47 +02:00
|
|
|
__func__, ioread32(I2C_REG_STS(alg_data)));
|
2006-12-10 21:21:29 +01:00
|
|
|
|
|
|
|
if (alg_data->mif.len > 0) {
|
|
|
|
/* We still have something to talk about... */
|
|
|
|
val = *alg_data->mif.buf++;
|
|
|
|
|
2010-03-16 23:55:37 +01:00
|
|
|
if (alg_data->mif.len == 1)
|
|
|
|
val |= stop_bit;
|
|
|
|
|
2006-12-10 21:21:29 +01:00
|
|
|
alg_data->mif.len--;
|
|
|
|
iowrite32(val, I2C_REG_TX(alg_data));
|
|
|
|
|
2009-11-21 13:46:31 +01:00
|
|
|
dev_dbg(&alg_data->adapter.dev, "%s(): xmit %#x [%d]\n",
|
|
|
|
__func__, val, alg_data->mif.len + 1);
|
2006-12-10 21:21:29 +01:00
|
|
|
|
|
|
|
if (alg_data->mif.len == 0) {
|
|
|
|
if (alg_data->last) {
|
|
|
|
/* Wait until the STOP is seen. */
|
2012-04-22 11:59:47 +02:00
|
|
|
if (wait_timeout(alg_data))
|
2009-11-21 13:46:31 +01:00
|
|
|
dev_err(&alg_data->adapter.dev,
|
|
|
|
"The bus is still active after timeout\n");
|
2006-12-10 21:21:29 +01:00
|
|
|
}
|
|
|
|
/* Disable master interrupts */
|
|
|
|
iowrite32(ioread32(I2C_REG_CTL(alg_data)) &
|
|
|
|
~(mcntrl_afie | mcntrl_naie | mcntrl_drmie),
|
|
|
|
I2C_REG_CTL(alg_data));
|
|
|
|
|
|
|
|
del_timer_sync(&alg_data->mif.timer);
|
|
|
|
|
2009-11-21 13:46:31 +01:00
|
|
|
dev_dbg(&alg_data->adapter.dev,
|
|
|
|
"%s(): Waking up xfer routine.\n",
|
2008-04-22 22:16:47 +02:00
|
|
|
__func__);
|
2006-12-10 21:21:29 +01:00
|
|
|
|
|
|
|
complete(&alg_data->mif.complete);
|
|
|
|
}
|
|
|
|
} else if (alg_data->mif.len == 0) {
|
|
|
|
/* zero-sized transfer */
|
2009-11-21 13:40:00 +01:00
|
|
|
i2c_pnx_stop(alg_data);
|
2006-12-10 21:21:29 +01:00
|
|
|
|
|
|
|
/* Disable master interrupts. */
|
|
|
|
iowrite32(ioread32(I2C_REG_CTL(alg_data)) &
|
|
|
|
~(mcntrl_afie | mcntrl_naie | mcntrl_drmie),
|
|
|
|
I2C_REG_CTL(alg_data));
|
|
|
|
|
|
|
|
/* Stop timer. */
|
|
|
|
del_timer_sync(&alg_data->mif.timer);
|
2009-11-21 13:46:31 +01:00
|
|
|
dev_dbg(&alg_data->adapter.dev,
|
|
|
|
"%s(): Waking up xfer routine after zero-xfer.\n",
|
|
|
|
__func__);
|
2006-12-10 21:21:29 +01:00
|
|
|
|
|
|
|
complete(&alg_data->mif.complete);
|
|
|
|
}
|
|
|
|
|
2009-11-21 13:40:00 +01:00
|
|
|
dev_dbg(&alg_data->adapter.dev, "%s(): exiting: stat = %04x.\n",
|
2008-04-22 22:16:47 +02:00
|
|
|
__func__, ioread32(I2C_REG_STS(alg_data)));
|
2006-12-10 21:21:29 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* i2c_pnx_master_rcv - receive data from slave
|
|
|
|
* @adap: pointer to I2C adapter structure
|
|
|
|
*
|
|
|
|
* Reads one byte data from the slave
|
|
|
|
*/
|
2009-11-21 13:40:00 +01:00
|
|
|
static int i2c_pnx_master_rcv(struct i2c_pnx_algo_data *alg_data)
|
2006-12-10 21:21:29 +01:00
|
|
|
{
|
|
|
|
unsigned int val = 0;
|
|
|
|
u32 ctl = 0;
|
|
|
|
|
2009-11-21 13:40:00 +01:00
|
|
|
dev_dbg(&alg_data->adapter.dev, "%s(): entering: stat = %04x.\n",
|
2008-04-22 22:16:47 +02:00
|
|
|
__func__, ioread32(I2C_REG_STS(alg_data)));
|
2006-12-10 21:21:29 +01:00
|
|
|
|
|
|
|
/* Check, whether there is already data,
|
|
|
|
* or we didn't 'ask' for it yet.
|
|
|
|
*/
|
|
|
|
if (ioread32(I2C_REG_STS(alg_data)) & mstatus_rfe) {
|
2012-08-08 09:42:32 +02:00
|
|
|
/* 'Asking' is done asynchronously, e.g. dummy TX of several
|
|
|
|
* bytes is done before the first actual RX arrives in FIFO.
|
|
|
|
* Therefore, ordered bytes (via TX) are counted separately.
|
|
|
|
*/
|
|
|
|
if (alg_data->mif.order) {
|
|
|
|
dev_dbg(&alg_data->adapter.dev,
|
|
|
|
"%s(): Write dummy data to fill Rx-fifo...\n",
|
|
|
|
__func__);
|
2006-12-10 21:21:29 +01:00
|
|
|
|
2012-08-08 09:42:32 +02:00
|
|
|
if (alg_data->mif.order == 1) {
|
|
|
|
/* Last byte, do not acknowledge next rcv. */
|
|
|
|
val |= stop_bit;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Enable interrupt RFDAIE (data in Rx fifo),
|
|
|
|
* and disable DRMIE (need data for Tx)
|
|
|
|
*/
|
|
|
|
ctl = ioread32(I2C_REG_CTL(alg_data));
|
|
|
|
ctl |= mcntrl_rffie | mcntrl_daie;
|
|
|
|
ctl &= ~mcntrl_drmie;
|
|
|
|
iowrite32(ctl, I2C_REG_CTL(alg_data));
|
|
|
|
}
|
2010-03-16 23:55:37 +01:00
|
|
|
|
2006-12-10 21:21:29 +01:00
|
|
|
/*
|
2012-08-08 09:42:32 +02:00
|
|
|
* Now we'll 'ask' for data:
|
|
|
|
* For each byte we want to receive, we must
|
|
|
|
* write a (dummy) byte to the Tx-FIFO.
|
2006-12-10 21:21:29 +01:00
|
|
|
*/
|
2012-08-08 09:42:32 +02:00
|
|
|
iowrite32(val, I2C_REG_TX(alg_data));
|
|
|
|
alg_data->mif.order--;
|
2006-12-10 21:21:29 +01:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Handle data. */
|
|
|
|
if (alg_data->mif.len > 0) {
|
|
|
|
val = ioread32(I2C_REG_RX(alg_data));
|
|
|
|
*alg_data->mif.buf++ = (u8) (val & 0xff);
|
2009-11-21 13:46:31 +01:00
|
|
|
dev_dbg(&alg_data->adapter.dev, "%s(): rcv 0x%x [%d]\n",
|
|
|
|
__func__, val, alg_data->mif.len);
|
2006-12-10 21:21:29 +01:00
|
|
|
|
|
|
|
alg_data->mif.len--;
|
|
|
|
if (alg_data->mif.len == 0) {
|
|
|
|
if (alg_data->last)
|
|
|
|
/* Wait until the STOP is seen. */
|
2012-04-22 11:59:47 +02:00
|
|
|
if (wait_timeout(alg_data))
|
2009-11-21 13:46:31 +01:00
|
|
|
dev_err(&alg_data->adapter.dev,
|
|
|
|
"The bus is still active after timeout\n");
|
2006-12-10 21:21:29 +01:00
|
|
|
|
|
|
|
/* Disable master interrupts */
|
|
|
|
ctl = ioread32(I2C_REG_CTL(alg_data));
|
|
|
|
ctl &= ~(mcntrl_afie | mcntrl_naie | mcntrl_rffie |
|
|
|
|
mcntrl_drmie | mcntrl_daie);
|
|
|
|
iowrite32(ctl, I2C_REG_CTL(alg_data));
|
|
|
|
|
|
|
|
/* Kill timer. */
|
|
|
|
del_timer_sync(&alg_data->mif.timer);
|
|
|
|
complete(&alg_data->mif.complete);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-21 13:40:00 +01:00
|
|
|
dev_dbg(&alg_data->adapter.dev, "%s(): exiting: stat = %04x.\n",
|
2008-04-22 22:16:47 +02:00
|
|
|
__func__, ioread32(I2C_REG_STS(alg_data)));
|
2006-12-10 21:21:29 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-01-04 13:07:03 +01:00
|
|
|
static irqreturn_t i2c_pnx_interrupt(int irq, void *dev_id)
|
2006-12-10 21:21:29 +01:00
|
|
|
{
|
2009-11-21 13:40:00 +01:00
|
|
|
struct i2c_pnx_algo_data *alg_data = dev_id;
|
2006-12-10 21:21:29 +01:00
|
|
|
u32 stat, ctl;
|
|
|
|
|
2009-11-21 13:46:31 +01:00
|
|
|
dev_dbg(&alg_data->adapter.dev,
|
|
|
|
"%s(): mstat = %x mctrl = %x, mode = %d\n",
|
2008-04-22 22:16:47 +02:00
|
|
|
__func__,
|
2006-12-10 21:21:29 +01:00
|
|
|
ioread32(I2C_REG_STS(alg_data)),
|
|
|
|
ioread32(I2C_REG_CTL(alg_data)),
|
|
|
|
alg_data->mif.mode);
|
|
|
|
stat = ioread32(I2C_REG_STS(alg_data));
|
|
|
|
|
|
|
|
/* let's see what kind of event this is */
|
|
|
|
if (stat & mstatus_afi) {
|
|
|
|
/* We lost arbitration in the midst of a transfer */
|
|
|
|
alg_data->mif.ret = -EIO;
|
|
|
|
|
|
|
|
/* Disable master interrupts. */
|
|
|
|
ctl = ioread32(I2C_REG_CTL(alg_data));
|
|
|
|
ctl &= ~(mcntrl_afie | mcntrl_naie | mcntrl_rffie |
|
|
|
|
mcntrl_drmie);
|
|
|
|
iowrite32(ctl, I2C_REG_CTL(alg_data));
|
|
|
|
|
|
|
|
/* Stop timer, to prevent timeout. */
|
|
|
|
del_timer_sync(&alg_data->mif.timer);
|
|
|
|
complete(&alg_data->mif.complete);
|
|
|
|
} else if (stat & mstatus_nai) {
|
|
|
|
/* Slave did not acknowledge, generate a STOP */
|
2009-11-21 13:46:31 +01:00
|
|
|
dev_dbg(&alg_data->adapter.dev,
|
|
|
|
"%s(): Slave did not acknowledge, generating a STOP.\n",
|
2008-04-22 22:16:47 +02:00
|
|
|
__func__);
|
2009-11-21 13:40:00 +01:00
|
|
|
i2c_pnx_stop(alg_data);
|
2006-12-10 21:21:29 +01:00
|
|
|
|
|
|
|
/* Disable master interrupts. */
|
|
|
|
ctl = ioread32(I2C_REG_CTL(alg_data));
|
|
|
|
ctl &= ~(mcntrl_afie | mcntrl_naie | mcntrl_rffie |
|
|
|
|
mcntrl_drmie);
|
|
|
|
iowrite32(ctl, I2C_REG_CTL(alg_data));
|
|
|
|
|
|
|
|
/* Our return value. */
|
|
|
|
alg_data->mif.ret = -EIO;
|
|
|
|
|
|
|
|
/* Stop timer, to prevent timeout. */
|
|
|
|
del_timer_sync(&alg_data->mif.timer);
|
|
|
|
complete(&alg_data->mif.complete);
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Two options:
|
|
|
|
* - Master Tx needs data.
|
|
|
|
* - There is data in the Rx-fifo
|
|
|
|
* The latter is only the case if we have requested for data,
|
|
|
|
* via a dummy write. (See 'i2c_pnx_master_rcv'.)
|
|
|
|
* We therefore check, as a sanity check, whether that interrupt
|
|
|
|
* has been enabled.
|
|
|
|
*/
|
|
|
|
if ((stat & mstatus_drmi) || !(stat & mstatus_rfe)) {
|
|
|
|
if (alg_data->mif.mode == I2C_SMBUS_WRITE) {
|
2009-11-21 13:40:00 +01:00
|
|
|
i2c_pnx_master_xmit(alg_data);
|
2006-12-10 21:21:29 +01:00
|
|
|
} else if (alg_data->mif.mode == I2C_SMBUS_READ) {
|
2009-11-21 13:40:00 +01:00
|
|
|
i2c_pnx_master_rcv(alg_data);
|
2006-12-10 21:21:29 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Clear TDI and AFI bits */
|
|
|
|
stat = ioread32(I2C_REG_STS(alg_data));
|
|
|
|
iowrite32(stat | mstatus_tdi | mstatus_afi, I2C_REG_STS(alg_data));
|
|
|
|
|
2009-11-21 13:46:31 +01:00
|
|
|
dev_dbg(&alg_data->adapter.dev,
|
|
|
|
"%s(): exiting, stat = %x ctrl = %x.\n",
|
2008-04-22 22:16:47 +02:00
|
|
|
__func__, ioread32(I2C_REG_STS(alg_data)),
|
2006-12-10 21:21:29 +01:00
|
|
|
ioread32(I2C_REG_CTL(alg_data)));
|
|
|
|
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
2017-10-17 01:27:29 +02:00
|
|
|
static void i2c_pnx_timeout(struct timer_list *t)
|
2006-12-10 21:21:29 +01:00
|
|
|
{
|
2017-10-17 01:27:29 +02:00
|
|
|
struct i2c_pnx_algo_data *alg_data = from_timer(alg_data, t, mif.timer);
|
2006-12-10 21:21:29 +01:00
|
|
|
u32 ctl;
|
|
|
|
|
2009-11-21 13:46:31 +01:00
|
|
|
dev_err(&alg_data->adapter.dev,
|
|
|
|
"Master timed out. stat = %04x, cntrl = %04x. Resetting master...\n",
|
|
|
|
ioread32(I2C_REG_STS(alg_data)),
|
|
|
|
ioread32(I2C_REG_CTL(alg_data)));
|
2006-12-10 21:21:29 +01:00
|
|
|
|
|
|
|
/* Reset master and disable interrupts */
|
|
|
|
ctl = ioread32(I2C_REG_CTL(alg_data));
|
|
|
|
ctl &= ~(mcntrl_afie | mcntrl_naie | mcntrl_rffie | mcntrl_drmie);
|
|
|
|
iowrite32(ctl, I2C_REG_CTL(alg_data));
|
|
|
|
|
|
|
|
ctl |= mcntrl_reset;
|
|
|
|
iowrite32(ctl, I2C_REG_CTL(alg_data));
|
2012-04-22 11:59:47 +02:00
|
|
|
wait_reset(alg_data);
|
2006-12-10 21:21:29 +01:00
|
|
|
alg_data->mif.ret = -EIO;
|
|
|
|
complete(&alg_data->mif.complete);
|
|
|
|
}
|
|
|
|
|
2009-11-21 13:40:00 +01:00
|
|
|
static inline void bus_reset_if_active(struct i2c_pnx_algo_data *alg_data)
|
2006-12-10 21:21:29 +01:00
|
|
|
{
|
|
|
|
u32 stat;
|
|
|
|
|
|
|
|
if ((stat = ioread32(I2C_REG_STS(alg_data))) & mstatus_active) {
|
2009-11-21 13:40:00 +01:00
|
|
|
dev_err(&alg_data->adapter.dev,
|
2006-12-10 21:21:29 +01:00
|
|
|
"%s: Bus is still active after xfer. Reset it...\n",
|
2009-11-21 13:46:31 +01:00
|
|
|
alg_data->adapter.name);
|
2006-12-10 21:21:29 +01:00
|
|
|
iowrite32(ioread32(I2C_REG_CTL(alg_data)) | mcntrl_reset,
|
|
|
|
I2C_REG_CTL(alg_data));
|
2012-04-22 11:59:47 +02:00
|
|
|
wait_reset(alg_data);
|
2006-12-10 21:21:29 +01:00
|
|
|
} else if (!(stat & mstatus_rfe) || !(stat & mstatus_tfe)) {
|
|
|
|
/* If there is data in the fifo's after transfer,
|
|
|
|
* flush fifo's by reset.
|
|
|
|
*/
|
|
|
|
iowrite32(ioread32(I2C_REG_CTL(alg_data)) | mcntrl_reset,
|
|
|
|
I2C_REG_CTL(alg_data));
|
2012-04-22 11:59:47 +02:00
|
|
|
wait_reset(alg_data);
|
2006-12-10 21:21:29 +01:00
|
|
|
} else if (stat & mstatus_nai) {
|
|
|
|
iowrite32(ioread32(I2C_REG_CTL(alg_data)) | mcntrl_reset,
|
|
|
|
I2C_REG_CTL(alg_data));
|
2012-04-22 11:59:47 +02:00
|
|
|
wait_reset(alg_data);
|
2006-12-10 21:21:29 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* i2c_pnx_xfer - generic transfer entry point
|
|
|
|
* @adap: pointer to I2C adapter structure
|
|
|
|
* @msgs: array of messages
|
|
|
|
* @num: number of messages
|
|
|
|
*
|
|
|
|
* Initiates the transfer
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
i2c_pnx_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
|
|
|
|
{
|
|
|
|
struct i2c_msg *pmsg;
|
|
|
|
int rc = 0, completed = 0, i;
|
|
|
|
struct i2c_pnx_algo_data *alg_data = adap->algo_data;
|
2015-10-25 16:20:59 +01:00
|
|
|
u32 stat;
|
2006-12-10 21:21:29 +01:00
|
|
|
|
2009-11-21 13:46:31 +01:00
|
|
|
dev_dbg(&alg_data->adapter.dev,
|
|
|
|
"%s(): entering: %d messages, stat = %04x.\n",
|
2008-04-22 22:16:47 +02:00
|
|
|
__func__, num, ioread32(I2C_REG_STS(alg_data)));
|
2006-12-10 21:21:29 +01:00
|
|
|
|
2009-11-21 13:40:00 +01:00
|
|
|
bus_reset_if_active(alg_data);
|
2006-12-10 21:21:29 +01:00
|
|
|
|
|
|
|
/* Process transactions in a loop. */
|
|
|
|
for (i = 0; rc >= 0 && i < num; i++) {
|
|
|
|
u8 addr;
|
|
|
|
|
|
|
|
pmsg = &msgs[i];
|
|
|
|
addr = pmsg->addr;
|
|
|
|
|
|
|
|
if (pmsg->flags & I2C_M_TEN) {
|
2009-11-21 13:40:00 +01:00
|
|
|
dev_err(&alg_data->adapter.dev,
|
2006-12-10 21:21:29 +01:00
|
|
|
"%s: 10 bits addr not supported!\n",
|
2009-11-21 13:40:00 +01:00
|
|
|
alg_data->adapter.name);
|
2006-12-10 21:21:29 +01:00
|
|
|
rc = -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
alg_data->mif.buf = pmsg->buf;
|
|
|
|
alg_data->mif.len = pmsg->len;
|
2012-08-08 09:42:32 +02:00
|
|
|
alg_data->mif.order = pmsg->len;
|
2006-12-10 21:21:29 +01:00
|
|
|
alg_data->mif.mode = (pmsg->flags & I2C_M_RD) ?
|
|
|
|
I2C_SMBUS_READ : I2C_SMBUS_WRITE;
|
|
|
|
alg_data->mif.ret = 0;
|
|
|
|
alg_data->last = (i == num - 1);
|
|
|
|
|
2009-11-21 13:46:31 +01:00
|
|
|
dev_dbg(&alg_data->adapter.dev, "%s(): mode %d, %d bytes\n",
|
|
|
|
__func__, alg_data->mif.mode, alg_data->mif.len);
|
2006-12-10 21:21:29 +01:00
|
|
|
|
2009-11-21 13:40:00 +01:00
|
|
|
i2c_pnx_arm_timer(alg_data);
|
2006-12-10 21:21:29 +01:00
|
|
|
|
|
|
|
/* initialize the completion var */
|
|
|
|
init_completion(&alg_data->mif.complete);
|
|
|
|
|
|
|
|
/* Enable master interrupt */
|
|
|
|
iowrite32(ioread32(I2C_REG_CTL(alg_data)) | mcntrl_afie |
|
|
|
|
mcntrl_naie | mcntrl_drmie,
|
|
|
|
I2C_REG_CTL(alg_data));
|
|
|
|
|
|
|
|
/* Put start-code and slave-address on the bus. */
|
2009-11-21 13:40:00 +01:00
|
|
|
rc = i2c_pnx_start(addr, alg_data);
|
2006-12-10 21:21:29 +01:00
|
|
|
if (rc < 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Wait for completion */
|
|
|
|
wait_for_completion(&alg_data->mif.complete);
|
|
|
|
|
|
|
|
if (!(rc = alg_data->mif.ret))
|
|
|
|
completed++;
|
2009-11-21 13:46:31 +01:00
|
|
|
dev_dbg(&alg_data->adapter.dev,
|
|
|
|
"%s(): Complete, return code = %d.\n",
|
2008-04-22 22:16:47 +02:00
|
|
|
__func__, rc);
|
2006-12-10 21:21:29 +01:00
|
|
|
|
|
|
|
/* Clear TDI and AFI bits in case they are set. */
|
|
|
|
if ((stat = ioread32(I2C_REG_STS(alg_data))) & mstatus_tdi) {
|
2009-11-21 13:40:00 +01:00
|
|
|
dev_dbg(&alg_data->adapter.dev,
|
2006-12-10 21:21:29 +01:00
|
|
|
"%s: TDI still set... clearing now.\n",
|
2009-11-21 13:40:00 +01:00
|
|
|
alg_data->adapter.name);
|
2006-12-10 21:21:29 +01:00
|
|
|
iowrite32(stat, I2C_REG_STS(alg_data));
|
|
|
|
}
|
|
|
|
if ((stat = ioread32(I2C_REG_STS(alg_data))) & mstatus_afi) {
|
2009-11-21 13:40:00 +01:00
|
|
|
dev_dbg(&alg_data->adapter.dev,
|
2006-12-10 21:21:29 +01:00
|
|
|
"%s: AFI still set... clearing now.\n",
|
2009-11-21 13:40:00 +01:00
|
|
|
alg_data->adapter.name);
|
2006-12-10 21:21:29 +01:00
|
|
|
iowrite32(stat, I2C_REG_STS(alg_data));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-21 13:40:00 +01:00
|
|
|
bus_reset_if_active(alg_data);
|
2006-12-10 21:21:29 +01:00
|
|
|
|
|
|
|
/* Cleanup to be sure... */
|
|
|
|
alg_data->mif.buf = NULL;
|
|
|
|
alg_data->mif.len = 0;
|
2012-08-08 09:42:32 +02:00
|
|
|
alg_data->mif.order = 0;
|
2006-12-10 21:21:29 +01:00
|
|
|
|
2009-11-21 13:40:00 +01:00
|
|
|
dev_dbg(&alg_data->adapter.dev, "%s(): exiting, stat = %x\n",
|
2008-04-22 22:16:47 +02:00
|
|
|
__func__, ioread32(I2C_REG_STS(alg_data)));
|
2006-12-10 21:21:29 +01:00
|
|
|
|
|
|
|
if (completed != num)
|
|
|
|
return ((rc < 0) ? rc : -EREMOTEIO);
|
|
|
|
|
|
|
|
return num;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32 i2c_pnx_func(struct i2c_adapter *adapter)
|
|
|
|
{
|
|
|
|
return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
|
|
|
|
}
|
|
|
|
|
2017-08-18 18:06:57 +02:00
|
|
|
static const struct i2c_algorithm pnx_algorithm = {
|
2006-12-10 21:21:29 +01:00
|
|
|
.master_xfer = i2c_pnx_xfer,
|
|
|
|
.functionality = i2c_pnx_func,
|
|
|
|
};
|
|
|
|
|
2013-07-15 04:30:17 +02:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2012-07-11 21:25:17 +02:00
|
|
|
static int i2c_pnx_controller_suspend(struct device *dev)
|
2006-12-10 21:21:29 +01:00
|
|
|
{
|
2012-07-11 21:25:17 +02:00
|
|
|
struct i2c_pnx_algo_data *alg_data = dev_get_drvdata(dev);
|
2009-11-20 12:12:26 +01:00
|
|
|
|
2015-10-17 20:52:27 +02:00
|
|
|
clk_disable_unprepare(alg_data->clk);
|
2009-11-20 12:12:26 +01:00
|
|
|
|
|
|
|
return 0;
|
2006-12-10 21:21:29 +01:00
|
|
|
}
|
|
|
|
|
2012-07-11 21:25:17 +02:00
|
|
|
static int i2c_pnx_controller_resume(struct device *dev)
|
2006-12-10 21:21:29 +01:00
|
|
|
{
|
2012-07-11 21:25:17 +02:00
|
|
|
struct i2c_pnx_algo_data *alg_data = dev_get_drvdata(dev);
|
2009-11-20 12:12:26 +01:00
|
|
|
|
2015-10-17 20:52:27 +02:00
|
|
|
return clk_prepare_enable(alg_data->clk);
|
2006-12-10 21:21:29 +01:00
|
|
|
}
|
2012-07-11 21:25:17 +02:00
|
|
|
|
|
|
|
static SIMPLE_DEV_PM_OPS(i2c_pnx_pm,
|
|
|
|
i2c_pnx_controller_suspend, i2c_pnx_controller_resume);
|
|
|
|
#define PNX_I2C_PM (&i2c_pnx_pm)
|
2009-11-20 11:50:34 +01:00
|
|
|
#else
|
2012-07-11 21:25:17 +02:00
|
|
|
#define PNX_I2C_PM NULL
|
2009-11-20 11:50:34 +01:00
|
|
|
#endif
|
2006-12-10 21:21:29 +01:00
|
|
|
|
2012-11-27 21:59:38 +01:00
|
|
|
static int i2c_pnx_probe(struct platform_device *pdev)
|
2006-12-10 21:21:29 +01:00
|
|
|
{
|
|
|
|
unsigned long tmp;
|
|
|
|
int ret = 0;
|
|
|
|
struct i2c_pnx_algo_data *alg_data;
|
2009-11-20 13:46:07 +01:00
|
|
|
unsigned long freq;
|
2012-04-22 11:59:47 +02:00
|
|
|
struct resource *res;
|
2012-04-22 11:59:47 +02:00
|
|
|
u32 speed = I2C_PNX_SPEED_KHZ_DEFAULT * 1000;
|
2006-12-10 21:21:29 +01:00
|
|
|
|
2014-01-14 01:19:30 +01:00
|
|
|
alg_data = devm_kzalloc(&pdev->dev, sizeof(*alg_data), GFP_KERNEL);
|
|
|
|
if (!alg_data)
|
|
|
|
return -ENOMEM;
|
2009-11-21 13:10:54 +01:00
|
|
|
|
2009-11-21 13:25:27 +01:00
|
|
|
platform_set_drvdata(pdev, alg_data);
|
2006-12-10 21:21:29 +01:00
|
|
|
|
2009-11-21 13:25:27 +01:00
|
|
|
alg_data->adapter.dev.parent = &pdev->dev;
|
|
|
|
alg_data->adapter.algo = &pnx_algorithm;
|
|
|
|
alg_data->adapter.algo_data = alg_data;
|
|
|
|
alg_data->adapter.nr = pdev->id;
|
2009-11-20 12:12:26 +01:00
|
|
|
|
2012-04-22 11:59:47 +02:00
|
|
|
alg_data->timeout = I2C_PNX_TIMEOUT_DEFAULT;
|
|
|
|
#ifdef CONFIG_OF
|
|
|
|
alg_data->adapter.dev.of_node = of_node_get(pdev->dev.of_node);
|
|
|
|
if (pdev->dev.of_node) {
|
|
|
|
of_property_read_u32(pdev->dev.of_node, "clock-frequency",
|
|
|
|
&speed);
|
|
|
|
/*
|
|
|
|
* At this point, it is planned to add an OF timeout property.
|
|
|
|
* As soon as there is a consensus about how to call and handle
|
|
|
|
* this, sth. like the following can be put here:
|
|
|
|
*
|
|
|
|
* of_property_read_u32(pdev->dev.of_node, "timeout",
|
|
|
|
* &alg_data->timeout);
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
#endif
|
2014-01-14 01:19:30 +01:00
|
|
|
alg_data->clk = devm_clk_get(&pdev->dev, NULL);
|
|
|
|
if (IS_ERR(alg_data->clk))
|
|
|
|
return PTR_ERR(alg_data->clk);
|
2009-11-20 12:12:26 +01:00
|
|
|
|
2017-10-17 01:27:29 +02:00
|
|
|
timer_setup(&alg_data->mif.timer, i2c_pnx_timeout, 0);
|
2006-12-10 21:21:29 +01:00
|
|
|
|
2012-04-22 11:59:47 +02:00
|
|
|
snprintf(alg_data->adapter.name, sizeof(alg_data->adapter.name),
|
|
|
|
"%s", pdev->name);
|
|
|
|
|
2006-12-10 21:21:29 +01:00
|
|
|
/* Register I/O resource */
|
2012-04-22 11:59:47 +02:00
|
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
2014-01-14 01:19:30 +01:00
|
|
|
alg_data->ioaddr = devm_ioremap_resource(&pdev->dev, res);
|
|
|
|
if (IS_ERR(alg_data->ioaddr))
|
|
|
|
return PTR_ERR(alg_data->ioaddr);
|
2006-12-10 21:21:29 +01:00
|
|
|
|
2015-10-17 20:52:27 +02:00
|
|
|
ret = clk_prepare_enable(alg_data->clk);
|
2009-11-20 12:44:46 +01:00
|
|
|
if (ret)
|
2014-01-14 01:19:30 +01:00
|
|
|
return ret;
|
2006-12-10 21:21:29 +01:00
|
|
|
|
2009-11-20 13:46:07 +01:00
|
|
|
freq = clk_get_rate(alg_data->clk);
|
|
|
|
|
2006-12-10 21:21:29 +01:00
|
|
|
/*
|
|
|
|
* Clock Divisor High This value is the number of system clocks
|
|
|
|
* the serial clock (SCL) will be high.
|
|
|
|
* For example, if the system clock period is 50 ns and the maximum
|
|
|
|
* desired serial period is 10000 ns (100 kHz), then CLKHI would be
|
|
|
|
* set to 0.5*(f_sys/f_i2c)-2=0.5*(20e6/100e3)-2=98. The actual value
|
|
|
|
* programmed into CLKHI will vary from this slightly due to
|
|
|
|
* variations in the output pad's rise and fall times as well as
|
|
|
|
* the deglitching filter length.
|
|
|
|
*/
|
|
|
|
|
2012-04-22 11:59:47 +02:00
|
|
|
tmp = (freq / speed) / 2 - 2;
|
2010-03-16 23:55:36 +01:00
|
|
|
if (tmp > 0x3FF)
|
|
|
|
tmp = 0x3FF;
|
2006-12-10 21:21:29 +01:00
|
|
|
iowrite32(tmp, I2C_REG_CKH(alg_data));
|
|
|
|
iowrite32(tmp, I2C_REG_CKL(alg_data));
|
|
|
|
|
|
|
|
iowrite32(mcntrl_reset, I2C_REG_CTL(alg_data));
|
2012-04-22 11:59:47 +02:00
|
|
|
if (wait_reset(alg_data)) {
|
2006-12-10 21:21:29 +01:00
|
|
|
ret = -ENODEV;
|
2009-11-20 12:44:46 +01:00
|
|
|
goto out_clock;
|
2006-12-10 21:21:29 +01:00
|
|
|
}
|
|
|
|
init_completion(&alg_data->mif.complete);
|
|
|
|
|
2012-04-22 11:59:47 +02:00
|
|
|
alg_data->irq = platform_get_irq(pdev, 0);
|
|
|
|
if (alg_data->irq < 0) {
|
|
|
|
dev_err(&pdev->dev, "Failed to get IRQ from platform resource\n");
|
2013-08-23 04:55:51 +02:00
|
|
|
ret = alg_data->irq;
|
|
|
|
goto out_clock;
|
2012-04-22 11:59:47 +02:00
|
|
|
}
|
2014-01-14 01:19:30 +01:00
|
|
|
ret = devm_request_irq(&pdev->dev, alg_data->irq, i2c_pnx_interrupt,
|
|
|
|
0, pdev->name, alg_data);
|
2006-12-10 21:21:29 +01:00
|
|
|
if (ret)
|
|
|
|
goto out_clock;
|
|
|
|
|
|
|
|
/* Register this adapter with the I2C subsystem */
|
2009-11-21 13:25:27 +01:00
|
|
|
ret = i2c_add_numbered_adapter(&alg_data->adapter);
|
2016-08-09 13:36:17 +02:00
|
|
|
if (ret < 0)
|
2014-01-14 01:19:30 +01:00
|
|
|
goto out_clock;
|
2006-12-10 21:21:29 +01:00
|
|
|
|
|
|
|
dev_dbg(&pdev->dev, "%s: Master at %#8x, irq %d.\n",
|
2012-04-22 11:59:47 +02:00
|
|
|
alg_data->adapter.name, res->start, alg_data->irq);
|
2006-12-10 21:21:29 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_clock:
|
2015-10-17 20:52:27 +02:00
|
|
|
clk_disable_unprepare(alg_data->clk);
|
2006-12-10 21:21:29 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-11-27 21:59:38 +01:00
|
|
|
static int i2c_pnx_remove(struct platform_device *pdev)
|
2006-12-10 21:21:29 +01:00
|
|
|
{
|
2009-11-21 13:25:27 +01:00
|
|
|
struct i2c_pnx_algo_data *alg_data = platform_get_drvdata(pdev);
|
2006-12-10 21:21:29 +01:00
|
|
|
|
2009-11-21 13:25:27 +01:00
|
|
|
i2c_del_adapter(&alg_data->adapter);
|
2015-10-17 20:52:27 +02:00
|
|
|
clk_disable_unprepare(alg_data->clk);
|
2006-12-10 21:21:29 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-04-22 11:59:47 +02:00
|
|
|
#ifdef CONFIG_OF
|
|
|
|
static const struct of_device_id i2c_pnx_of_match[] = {
|
|
|
|
{ .compatible = "nxp,pnx-i2c" },
|
|
|
|
{ },
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(of, i2c_pnx_of_match);
|
|
|
|
#endif
|
|
|
|
|
2006-12-10 21:21:29 +01:00
|
|
|
static struct platform_driver i2c_pnx_driver = {
|
|
|
|
.driver = {
|
|
|
|
.name = "pnx-i2c",
|
2012-04-22 11:59:47 +02:00
|
|
|
.of_match_table = of_match_ptr(i2c_pnx_of_match),
|
2012-07-11 21:25:17 +02:00
|
|
|
.pm = PNX_I2C_PM,
|
2006-12-10 21:21:29 +01:00
|
|
|
},
|
|
|
|
.probe = i2c_pnx_probe,
|
2012-11-27 21:59:38 +01:00
|
|
|
.remove = i2c_pnx_remove,
|
2006-12-10 21:21:29 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
static int __init i2c_adap_pnx_init(void)
|
|
|
|
{
|
|
|
|
return platform_driver_register(&i2c_pnx_driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit i2c_adap_pnx_exit(void)
|
|
|
|
{
|
|
|
|
platform_driver_unregister(&i2c_pnx_driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Vitaly Wool, Dennis Kovalev <source@mvista.com>");
|
|
|
|
MODULE_DESCRIPTION("I2C driver for Philips IP3204-based I2C busses");
|
|
|
|
MODULE_LICENSE("GPL");
|
2008-04-22 22:16:49 +02:00
|
|
|
MODULE_ALIAS("platform:pnx-i2c");
|
2006-12-10 21:21:29 +01:00
|
|
|
|
|
|
|
/* We need to make sure I2C is initialized before USB */
|
|
|
|
subsys_initcall(i2c_adap_pnx_init);
|
|
|
|
module_exit(i2c_adap_pnx_exit);
|