2009-01-30 11:32:28 +03:00
|
|
|
/*
|
|
|
|
|
* Copyright (C) 2002 Motorola GSG-China
|
|
|
|
|
*
|
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
|
* of the License, or (at your option) any later version.
|
|
|
|
|
*
|
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
|
|
|
|
* USA.
|
|
|
|
|
*
|
|
|
|
|
* Author:
|
|
|
|
|
* Darius Augulis, Teltonika Inc.
|
|
|
|
|
*
|
|
|
|
|
* Desc.:
|
|
|
|
|
* Implementation of I2C Adapter/Algorithm Driver
|
|
|
|
|
* for I2C Bus integrated in Freescale i.MX/MXC processors
|
|
|
|
|
*
|
|
|
|
|
* Derived from Motorola GSG China I2C example driver
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 2005 Torsten Koschorrek <koschorrek at synertronixx.de
|
|
|
|
|
* Copyright (C) 2005 Matthias Blaschke <blaschke at synertronixx.de
|
|
|
|
|
* Copyright (C) 2007 RightHand Technologies, Inc.
|
|
|
|
|
* Copyright (C) 2008 Darius Augulis <darius.augulis at teltonika.lt>
|
|
|
|
|
*
|
2013-08-07 13:05:36 +04:00
|
|
|
* Copyright 2013 Freescale Semiconductor, Inc.
|
|
|
|
|
*
|
2009-01-30 11:32:28 +03:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/** Includes *******************************************************************
|
|
|
|
|
*******************************************************************************/
|
|
|
|
|
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
|
#include <linux/errno.h>
|
|
|
|
|
#include <linux/err.h>
|
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
|
#include <linux/delay.h>
|
|
|
|
|
#include <linux/i2c.h>
|
|
|
|
|
#include <linux/io.h>
|
|
|
|
|
#include <linux/sched.h>
|
|
|
|
|
#include <linux/platform_device.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 11:04:11 +03:00
|
|
|
#include <linux/slab.h>
|
2011-09-08 11:09:35 +04:00
|
|
|
#include <linux/of.h>
|
|
|
|
|
#include <linux/of_device.h>
|
2012-08-24 17:14:29 +04:00
|
|
|
#include <linux/platform_data/i2c-imx.h>
|
2009-01-30 11:32:28 +03:00
|
|
|
|
|
|
|
|
/** Defines ********************************************************************
|
|
|
|
|
*******************************************************************************/
|
|
|
|
|
|
|
|
|
|
/* This will be the driver name the kernel reports */
|
|
|
|
|
#define DRIVER_NAME "imx-i2c"
|
|
|
|
|
|
|
|
|
|
/* Default value */
|
|
|
|
|
#define IMX_I2C_BIT_RATE 100000 /* 100kHz */
|
|
|
|
|
|
2013-08-07 13:05:40 +04:00
|
|
|
/* IMX I2C registers:
|
|
|
|
|
* the I2C register offset is different between SoCs,
|
|
|
|
|
* to provid support for all these chips, split the
|
|
|
|
|
* register offset into a fixed base address and a
|
|
|
|
|
* variable shift value, then the full register offset
|
|
|
|
|
* will be calculated by
|
|
|
|
|
* reg_off = ( reg_base_addr << reg_shift)
|
|
|
|
|
*/
|
2009-01-30 11:32:28 +03:00
|
|
|
#define IMX_I2C_IADR 0x00 /* i2c slave address */
|
2013-08-07 13:05:40 +04:00
|
|
|
#define IMX_I2C_IFDR 0x01 /* i2c frequency divider */
|
|
|
|
|
#define IMX_I2C_I2CR 0x02 /* i2c control */
|
|
|
|
|
#define IMX_I2C_I2SR 0x03 /* i2c status */
|
|
|
|
|
#define IMX_I2C_I2DR 0x04 /* i2c transfer data */
|
|
|
|
|
|
|
|
|
|
#define IMX_I2C_REGSHIFT 2
|
2013-08-07 13:05:43 +04:00
|
|
|
#define VF610_I2C_REGSHIFT 0
|
2009-01-30 11:32:28 +03:00
|
|
|
|
|
|
|
|
/* Bits of IMX I2C registers */
|
|
|
|
|
#define I2SR_RXAK 0x01
|
|
|
|
|
#define I2SR_IIF 0x02
|
|
|
|
|
#define I2SR_SRW 0x04
|
|
|
|
|
#define I2SR_IAL 0x10
|
|
|
|
|
#define I2SR_IBB 0x20
|
|
|
|
|
#define I2SR_IAAS 0x40
|
|
|
|
|
#define I2SR_ICF 0x80
|
|
|
|
|
#define I2CR_RSTA 0x04
|
|
|
|
|
#define I2CR_TXAK 0x08
|
|
|
|
|
#define I2CR_MTX 0x10
|
|
|
|
|
#define I2CR_MSTA 0x20
|
|
|
|
|
#define I2CR_IIEN 0x40
|
|
|
|
|
#define I2CR_IEN 0x80
|
|
|
|
|
|
2013-08-07 13:05:41 +04:00
|
|
|
/* register bits different operating codes definition:
|
|
|
|
|
* 1) I2SR: Interrupt flags clear operation differ between SoCs:
|
|
|
|
|
* - write zero to clear(w0c) INT flag on i.MX,
|
|
|
|
|
* - but write one to clear(w1c) INT flag on Vybrid.
|
|
|
|
|
* 2) I2CR: I2C module enable operation also differ between SoCs:
|
|
|
|
|
* - set I2CR_IEN bit enable the module on i.MX,
|
|
|
|
|
* - but clear I2CR_IEN bit enable the module on Vybrid.
|
|
|
|
|
*/
|
|
|
|
|
#define I2SR_CLR_OPCODE_W0C 0x0
|
|
|
|
|
#define I2SR_CLR_OPCODE_W1C (I2SR_IAL | I2SR_IIF)
|
|
|
|
|
#define I2CR_IEN_OPCODE_0 0x0
|
|
|
|
|
#define I2CR_IEN_OPCODE_1 I2CR_IEN
|
|
|
|
|
|
2009-01-30 11:32:28 +03:00
|
|
|
/** Variables ******************************************************************
|
|
|
|
|
*******************************************************************************/
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* sorted list of clock divider, register value pairs
|
|
|
|
|
* taken from table 26-5, p.26-9, Freescale i.MX
|
|
|
|
|
* Integrated Portable System Processor Reference Manual
|
|
|
|
|
* Document Number: MC9328MXLRM, Rev. 5.1, 06/2007
|
|
|
|
|
*
|
|
|
|
|
* Duplicated divider values removed from list
|
|
|
|
|
*/
|
2013-08-07 13:05:36 +04:00
|
|
|
struct imx_i2c_clk_pair {
|
|
|
|
|
u16 div;
|
|
|
|
|
u16 val;
|
|
|
|
|
};
|
2009-01-30 11:32:28 +03:00
|
|
|
|
2013-08-07 13:05:42 +04:00
|
|
|
static struct imx_i2c_clk_pair imx_i2c_clk_div[] = {
|
2009-01-30 11:32:28 +03:00
|
|
|
{ 22, 0x20 }, { 24, 0x21 }, { 26, 0x22 }, { 28, 0x23 },
|
|
|
|
|
{ 30, 0x00 }, { 32, 0x24 }, { 36, 0x25 }, { 40, 0x26 },
|
|
|
|
|
{ 42, 0x03 }, { 44, 0x27 }, { 48, 0x28 }, { 52, 0x05 },
|
|
|
|
|
{ 56, 0x29 }, { 60, 0x06 }, { 64, 0x2A }, { 72, 0x2B },
|
|
|
|
|
{ 80, 0x2C }, { 88, 0x09 }, { 96, 0x2D }, { 104, 0x0A },
|
|
|
|
|
{ 112, 0x2E }, { 128, 0x2F }, { 144, 0x0C }, { 160, 0x30 },
|
|
|
|
|
{ 192, 0x31 }, { 224, 0x32 }, { 240, 0x0F }, { 256, 0x33 },
|
|
|
|
|
{ 288, 0x10 }, { 320, 0x34 }, { 384, 0x35 }, { 448, 0x36 },
|
|
|
|
|
{ 480, 0x13 }, { 512, 0x37 }, { 576, 0x14 }, { 640, 0x38 },
|
|
|
|
|
{ 768, 0x39 }, { 896, 0x3A }, { 960, 0x17 }, { 1024, 0x3B },
|
|
|
|
|
{ 1152, 0x18 }, { 1280, 0x3C }, { 1536, 0x3D }, { 1792, 0x3E },
|
|
|
|
|
{ 1920, 0x1B }, { 2048, 0x3F }, { 2304, 0x1C }, { 2560, 0x1D },
|
|
|
|
|
{ 3072, 0x1E }, { 3840, 0x1F }
|
|
|
|
|
};
|
|
|
|
|
|
2013-08-07 13:05:43 +04:00
|
|
|
/* Vybrid VF610 clock divider, register value pairs */
|
|
|
|
|
static struct imx_i2c_clk_pair vf610_i2c_clk_div[] = {
|
|
|
|
|
{ 20, 0x00 }, { 22, 0x01 }, { 24, 0x02 }, { 26, 0x03 },
|
|
|
|
|
{ 28, 0x04 }, { 30, 0x05 }, { 32, 0x09 }, { 34, 0x06 },
|
|
|
|
|
{ 36, 0x0A }, { 40, 0x07 }, { 44, 0x0C }, { 48, 0x0D },
|
|
|
|
|
{ 52, 0x43 }, { 56, 0x0E }, { 60, 0x45 }, { 64, 0x12 },
|
|
|
|
|
{ 68, 0x0F }, { 72, 0x13 }, { 80, 0x14 }, { 88, 0x15 },
|
|
|
|
|
{ 96, 0x19 }, { 104, 0x16 }, { 112, 0x1A }, { 128, 0x17 },
|
|
|
|
|
{ 136, 0x4F }, { 144, 0x1C }, { 160, 0x1D }, { 176, 0x55 },
|
|
|
|
|
{ 192, 0x1E }, { 208, 0x56 }, { 224, 0x22 }, { 228, 0x24 },
|
|
|
|
|
{ 240, 0x1F }, { 256, 0x23 }, { 288, 0x5C }, { 320, 0x25 },
|
|
|
|
|
{ 384, 0x26 }, { 448, 0x2A }, { 480, 0x27 }, { 512, 0x2B },
|
|
|
|
|
{ 576, 0x2C }, { 640, 0x2D }, { 768, 0x31 }, { 896, 0x32 },
|
|
|
|
|
{ 960, 0x2F }, { 1024, 0x33 }, { 1152, 0x34 }, { 1280, 0x35 },
|
|
|
|
|
{ 1536, 0x36 }, { 1792, 0x3A }, { 1920, 0x37 }, { 2048, 0x3B },
|
|
|
|
|
{ 2304, 0x3C }, { 2560, 0x3D }, { 3072, 0x3E }, { 3584, 0x7A },
|
|
|
|
|
{ 3840, 0x3F }, { 4096, 0x7B }, { 5120, 0x7D }, { 6144, 0x7E },
|
|
|
|
|
};
|
|
|
|
|
|
2012-09-14 11:19:00 +04:00
|
|
|
enum imx_i2c_type {
|
|
|
|
|
IMX1_I2C,
|
|
|
|
|
IMX21_I2C,
|
2013-08-07 13:05:43 +04:00
|
|
|
VF610_I2C,
|
2012-09-14 11:19:00 +04:00
|
|
|
};
|
|
|
|
|
|
2013-08-07 13:05:42 +04:00
|
|
|
struct imx_i2c_hwdata {
|
|
|
|
|
enum imx_i2c_type devtype;
|
|
|
|
|
unsigned regshift;
|
|
|
|
|
struct imx_i2c_clk_pair *clk_div;
|
|
|
|
|
unsigned ndivs;
|
|
|
|
|
unsigned i2sr_clr_opcode;
|
|
|
|
|
unsigned i2cr_ien_opcode;
|
|
|
|
|
};
|
|
|
|
|
|
2009-01-30 11:32:28 +03:00
|
|
|
struct imx_i2c_struct {
|
|
|
|
|
struct i2c_adapter adapter;
|
|
|
|
|
struct clk *clk;
|
|
|
|
|
void __iomem *base;
|
|
|
|
|
wait_queue_head_t queue;
|
|
|
|
|
unsigned long i2csr;
|
2009-04-06 18:27:45 +04:00
|
|
|
unsigned int disable_delay;
|
2009-10-17 13:46:22 +04:00
|
|
|
int stopped;
|
2009-10-17 13:46:24 +04:00
|
|
|
unsigned int ifdr; /* IMX_I2C_IFDR */
|
2013-08-07 13:05:42 +04:00
|
|
|
const struct imx_i2c_hwdata *hwdata;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const struct imx_i2c_hwdata imx1_i2c_hwdata = {
|
|
|
|
|
.devtype = IMX1_I2C,
|
|
|
|
|
.regshift = IMX_I2C_REGSHIFT,
|
|
|
|
|
.clk_div = imx_i2c_clk_div,
|
|
|
|
|
.ndivs = ARRAY_SIZE(imx_i2c_clk_div),
|
|
|
|
|
.i2sr_clr_opcode = I2SR_CLR_OPCODE_W0C,
|
|
|
|
|
.i2cr_ien_opcode = I2CR_IEN_OPCODE_1,
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const struct imx_i2c_hwdata imx21_i2c_hwdata = {
|
|
|
|
|
.devtype = IMX21_I2C,
|
|
|
|
|
.regshift = IMX_I2C_REGSHIFT,
|
|
|
|
|
.clk_div = imx_i2c_clk_div,
|
|
|
|
|
.ndivs = ARRAY_SIZE(imx_i2c_clk_div),
|
|
|
|
|
.i2sr_clr_opcode = I2SR_CLR_OPCODE_W0C,
|
|
|
|
|
.i2cr_ien_opcode = I2CR_IEN_OPCODE_1,
|
|
|
|
|
|
2012-09-14 11:19:00 +04:00
|
|
|
};
|
|
|
|
|
|
2013-08-07 13:05:43 +04:00
|
|
|
static struct imx_i2c_hwdata vf610_i2c_hwdata = {
|
|
|
|
|
.devtype = VF610_I2C,
|
|
|
|
|
.regshift = VF610_I2C_REGSHIFT,
|
|
|
|
|
.clk_div = vf610_i2c_clk_div,
|
|
|
|
|
.ndivs = ARRAY_SIZE(vf610_i2c_clk_div),
|
|
|
|
|
.i2sr_clr_opcode = I2SR_CLR_OPCODE_W1C,
|
|
|
|
|
.i2cr_ien_opcode = I2CR_IEN_OPCODE_0,
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
2012-09-14 11:19:00 +04:00
|
|
|
static struct platform_device_id imx_i2c_devtype[] = {
|
|
|
|
|
{
|
|
|
|
|
.name = "imx1-i2c",
|
2013-08-07 13:05:42 +04:00
|
|
|
.driver_data = (kernel_ulong_t)&imx1_i2c_hwdata,
|
2012-09-14 11:19:00 +04:00
|
|
|
}, {
|
|
|
|
|
.name = "imx21-i2c",
|
2013-08-07 13:05:42 +04:00
|
|
|
.driver_data = (kernel_ulong_t)&imx21_i2c_hwdata,
|
2012-09-14 11:19:00 +04:00
|
|
|
}, {
|
|
|
|
|
/* sentinel */
|
|
|
|
|
}
|
2009-01-30 11:32:28 +03:00
|
|
|
};
|
2012-09-14 11:19:00 +04:00
|
|
|
MODULE_DEVICE_TABLE(platform, imx_i2c_devtype);
|
2009-01-30 11:32:28 +03:00
|
|
|
|
2011-09-08 11:09:35 +04:00
|
|
|
static const struct of_device_id i2c_imx_dt_ids[] = {
|
2013-08-07 13:05:42 +04:00
|
|
|
{ .compatible = "fsl,imx1-i2c", .data = &imx1_i2c_hwdata, },
|
|
|
|
|
{ .compatible = "fsl,imx21-i2c", .data = &imx21_i2c_hwdata, },
|
2013-08-07 13:05:43 +04:00
|
|
|
{ .compatible = "fsl,vf610-i2c", .data = &vf610_i2c_hwdata, },
|
2011-09-08 11:09:35 +04:00
|
|
|
{ /* sentinel */ }
|
|
|
|
|
};
|
2013-06-21 01:07:06 +04:00
|
|
|
MODULE_DEVICE_TABLE(of, i2c_imx_dt_ids);
|
2011-09-08 11:09:35 +04:00
|
|
|
|
2012-09-14 11:19:00 +04:00
|
|
|
static inline int is_imx1_i2c(struct imx_i2c_struct *i2c_imx)
|
|
|
|
|
{
|
2013-08-07 13:05:42 +04:00
|
|
|
return i2c_imx->hwdata->devtype == IMX1_I2C;
|
2012-09-14 11:19:00 +04:00
|
|
|
}
|
|
|
|
|
|
2013-08-07 13:05:39 +04:00
|
|
|
static inline void imx_i2c_write_reg(unsigned int val,
|
|
|
|
|
struct imx_i2c_struct *i2c_imx, unsigned int reg)
|
|
|
|
|
{
|
2013-08-07 13:05:42 +04:00
|
|
|
writeb(val, i2c_imx->base + (reg << i2c_imx->hwdata->regshift));
|
2013-08-07 13:05:39 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline unsigned char imx_i2c_read_reg(struct imx_i2c_struct *i2c_imx,
|
|
|
|
|
unsigned int reg)
|
|
|
|
|
{
|
2013-08-07 13:05:42 +04:00
|
|
|
return readb(i2c_imx->base + (reg << i2c_imx->hwdata->regshift));
|
2013-08-07 13:05:39 +04:00
|
|
|
}
|
|
|
|
|
|
2009-01-30 11:32:28 +03:00
|
|
|
/** Functions for IMX I2C adapter driver ***************************************
|
|
|
|
|
*******************************************************************************/
|
|
|
|
|
|
2009-10-17 13:46:22 +04:00
|
|
|
static int i2c_imx_bus_busy(struct imx_i2c_struct *i2c_imx, int for_busy)
|
2009-01-30 11:32:28 +03:00
|
|
|
{
|
|
|
|
|
unsigned long orig_jiffies = jiffies;
|
2009-10-17 13:46:22 +04:00
|
|
|
unsigned int temp;
|
2009-01-30 11:32:28 +03:00
|
|
|
|
|
|
|
|
dev_dbg(&i2c_imx->adapter.dev, "<%s>\n", __func__);
|
|
|
|
|
|
2009-10-17 13:46:22 +04:00
|
|
|
while (1) {
|
2013-08-07 13:05:39 +04:00
|
|
|
temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2SR);
|
2009-10-17 13:46:22 +04:00
|
|
|
if (for_busy && (temp & I2SR_IBB))
|
|
|
|
|
break;
|
|
|
|
|
if (!for_busy && !(temp & I2SR_IBB))
|
|
|
|
|
break;
|
2010-03-23 19:28:28 +03:00
|
|
|
if (time_after(jiffies, orig_jiffies + msecs_to_jiffies(500))) {
|
2009-01-30 11:32:28 +03:00
|
|
|
dev_dbg(&i2c_imx->adapter.dev,
|
|
|
|
|
"<%s> I2C bus is busy\n", __func__);
|
2010-03-23 19:28:28 +03:00
|
|
|
return -ETIMEDOUT;
|
2009-01-30 11:32:28 +03:00
|
|
|
}
|
|
|
|
|
schedule();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int i2c_imx_trx_complete(struct imx_i2c_struct *i2c_imx)
|
|
|
|
|
{
|
2010-06-21 11:27:05 +04:00
|
|
|
wait_event_timeout(i2c_imx->queue, i2c_imx->i2csr & I2SR_IIF, HZ / 10);
|
2009-01-30 11:32:28 +03:00
|
|
|
|
2010-06-21 11:27:05 +04:00
|
|
|
if (unlikely(!(i2c_imx->i2csr & I2SR_IIF))) {
|
2009-01-30 11:32:28 +03:00
|
|
|
dev_dbg(&i2c_imx->adapter.dev, "<%s> Timeout\n", __func__);
|
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
|
}
|
|
|
|
|
dev_dbg(&i2c_imx->adapter.dev, "<%s> TRX complete\n", __func__);
|
|
|
|
|
i2c_imx->i2csr = 0;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int i2c_imx_acked(struct imx_i2c_struct *i2c_imx)
|
|
|
|
|
{
|
2013-08-07 13:05:39 +04:00
|
|
|
if (imx_i2c_read_reg(i2c_imx, IMX_I2C_I2SR) & I2SR_RXAK) {
|
2009-01-30 11:32:28 +03:00
|
|
|
dev_dbg(&i2c_imx->adapter.dev, "<%s> No ACK\n", __func__);
|
|
|
|
|
return -EIO; /* No ACK */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
dev_dbg(&i2c_imx->adapter.dev, "<%s> ACK received\n", __func__);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2009-10-17 13:46:22 +04:00
|
|
|
static int i2c_imx_start(struct imx_i2c_struct *i2c_imx)
|
2009-01-30 11:32:28 +03:00
|
|
|
{
|
|
|
|
|
unsigned int temp = 0;
|
2009-10-17 13:46:22 +04:00
|
|
|
int result;
|
2009-01-30 11:32:28 +03:00
|
|
|
|
|
|
|
|
dev_dbg(&i2c_imx->adapter.dev, "<%s>\n", __func__);
|
|
|
|
|
|
2011-11-15 10:48:08 +04:00
|
|
|
clk_prepare_enable(i2c_imx->clk);
|
2013-08-07 13:05:39 +04:00
|
|
|
imx_i2c_write_reg(i2c_imx->ifdr, i2c_imx, IMX_I2C_IFDR);
|
2009-01-30 11:32:28 +03:00
|
|
|
/* Enable I2C controller */
|
2013-08-07 13:05:42 +04:00
|
|
|
imx_i2c_write_reg(i2c_imx->hwdata->i2sr_clr_opcode, i2c_imx, IMX_I2C_I2SR);
|
|
|
|
|
imx_i2c_write_reg(i2c_imx->hwdata->i2cr_ien_opcode, i2c_imx, IMX_I2C_I2CR);
|
2009-10-17 13:46:22 +04:00
|
|
|
|
|
|
|
|
/* Wait controller to be stable */
|
|
|
|
|
udelay(50);
|
|
|
|
|
|
2009-01-30 11:32:28 +03:00
|
|
|
/* Start I2C transaction */
|
2013-08-07 13:05:39 +04:00
|
|
|
temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR);
|
2009-01-30 11:32:28 +03:00
|
|
|
temp |= I2CR_MSTA;
|
2013-08-07 13:05:39 +04:00
|
|
|
imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR);
|
2009-10-17 13:46:22 +04:00
|
|
|
result = i2c_imx_bus_busy(i2c_imx, 1);
|
|
|
|
|
if (result)
|
|
|
|
|
return result;
|
|
|
|
|
i2c_imx->stopped = 0;
|
|
|
|
|
|
2009-01-30 11:32:28 +03:00
|
|
|
temp |= I2CR_IIEN | I2CR_MTX | I2CR_TXAK;
|
2013-08-07 13:05:39 +04:00
|
|
|
imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR);
|
2009-10-17 13:46:22 +04:00
|
|
|
return result;
|
2009-01-30 11:32:28 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void i2c_imx_stop(struct imx_i2c_struct *i2c_imx)
|
|
|
|
|
{
|
|
|
|
|
unsigned int temp = 0;
|
|
|
|
|
|
2009-10-17 13:46:22 +04:00
|
|
|
if (!i2c_imx->stopped) {
|
|
|
|
|
/* Stop I2C transaction */
|
|
|
|
|
dev_dbg(&i2c_imx->adapter.dev, "<%s>\n", __func__);
|
2013-08-07 13:05:39 +04:00
|
|
|
temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR);
|
2009-10-17 13:46:22 +04:00
|
|
|
temp &= ~(I2CR_MSTA | I2CR_MTX);
|
2013-08-07 13:05:39 +04:00
|
|
|
imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR);
|
2009-10-17 13:46:22 +04:00
|
|
|
}
|
2012-09-14 11:19:00 +04:00
|
|
|
if (is_imx1_i2c(i2c_imx)) {
|
2009-10-17 13:46:23 +04:00
|
|
|
/*
|
|
|
|
|
* This delay caused by an i.MXL hardware bug.
|
|
|
|
|
* If no (or too short) delay, no "STOP" bit will be generated.
|
|
|
|
|
*/
|
|
|
|
|
udelay(i2c_imx->disable_delay);
|
|
|
|
|
}
|
2009-10-17 13:46:22 +04:00
|
|
|
|
2010-01-21 20:55:32 +03:00
|
|
|
if (!i2c_imx->stopped) {
|
2009-10-17 13:46:22 +04:00
|
|
|
i2c_imx_bus_busy(i2c_imx, 0);
|
2010-01-21 20:55:32 +03:00
|
|
|
i2c_imx->stopped = 1;
|
|
|
|
|
}
|
2009-10-17 13:46:22 +04:00
|
|
|
|
2009-01-30 11:32:28 +03:00
|
|
|
/* Disable I2C controller */
|
2013-08-07 13:05:42 +04:00
|
|
|
temp = i2c_imx->hwdata->i2cr_ien_opcode ^ I2CR_IEN,
|
|
|
|
|
imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR);
|
2011-11-15 10:48:08 +04:00
|
|
|
clk_disable_unprepare(i2c_imx->clk);
|
2009-01-30 11:32:28 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void __init i2c_imx_set_clk(struct imx_i2c_struct *i2c_imx,
|
|
|
|
|
unsigned int rate)
|
|
|
|
|
{
|
2013-08-07 13:05:42 +04:00
|
|
|
struct imx_i2c_clk_pair *i2c_clk_div = i2c_imx->hwdata->clk_div;
|
2009-01-30 11:32:28 +03:00
|
|
|
unsigned int i2c_clk_rate;
|
|
|
|
|
unsigned int div;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
/* Divider value calculation */
|
|
|
|
|
i2c_clk_rate = clk_get_rate(i2c_imx->clk);
|
|
|
|
|
div = (i2c_clk_rate + rate - 1) / rate;
|
2013-08-07 13:05:36 +04:00
|
|
|
if (div < i2c_clk_div[0].div)
|
2009-01-30 11:32:28 +03:00
|
|
|
i = 0;
|
2013-08-07 13:05:42 +04:00
|
|
|
else if (div > i2c_clk_div[i2c_imx->hwdata->ndivs - 1].div)
|
|
|
|
|
i = i2c_imx->hwdata->ndivs - 1;
|
2009-01-30 11:32:28 +03:00
|
|
|
else
|
2013-08-07 13:05:36 +04:00
|
|
|
for (i = 0; i2c_clk_div[i].div < div; i++);
|
2009-01-30 11:32:28 +03:00
|
|
|
|
2009-10-17 13:46:24 +04:00
|
|
|
/* Store divider value */
|
2013-08-07 13:05:36 +04:00
|
|
|
i2c_imx->ifdr = i2c_clk_div[i].val;
|
2009-01-30 11:32:28 +03:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* There dummy delay is calculated.
|
|
|
|
|
* It should be about one I2C clock period long.
|
|
|
|
|
* This delay is used in I2C bus disable function
|
|
|
|
|
* to fix chip hardware bug.
|
|
|
|
|
*/
|
2013-08-07 13:05:36 +04:00
|
|
|
i2c_imx->disable_delay = (500000U * i2c_clk_div[i].div
|
2009-01-30 11:32:28 +03:00
|
|
|
+ (i2c_clk_rate / 2) - 1) / (i2c_clk_rate / 2);
|
|
|
|
|
|
|
|
|
|
/* dev_dbg() can't be used, because adapter is not yet registered */
|
|
|
|
|
#ifdef CONFIG_I2C_DEBUG_BUS
|
2012-08-02 00:38:15 +04:00
|
|
|
dev_dbg(&i2c_imx->adapter.dev, "<%s> I2C_CLK=%d, REQ DIV=%d\n",
|
2009-01-30 11:32:28 +03:00
|
|
|
__func__, i2c_clk_rate, div);
|
2012-08-02 00:38:15 +04:00
|
|
|
dev_dbg(&i2c_imx->adapter.dev, "<%s> IFDR[IC]=0x%x, REAL DIV=%d\n",
|
2013-08-07 13:05:36 +04:00
|
|
|
__func__, i2c_clk_div[i].val, i2c_clk_div[i].div);
|
2009-01-30 11:32:28 +03:00
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static irqreturn_t i2c_imx_isr(int irq, void *dev_id)
|
|
|
|
|
{
|
|
|
|
|
struct imx_i2c_struct *i2c_imx = dev_id;
|
|
|
|
|
unsigned int temp;
|
|
|
|
|
|
2013-08-07 13:05:39 +04:00
|
|
|
temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2SR);
|
2009-01-30 11:32:28 +03:00
|
|
|
if (temp & I2SR_IIF) {
|
|
|
|
|
/* save status register */
|
|
|
|
|
i2c_imx->i2csr = temp;
|
|
|
|
|
temp &= ~I2SR_IIF;
|
2013-08-07 13:05:42 +04:00
|
|
|
temp |= (i2c_imx->hwdata->i2sr_clr_opcode & I2SR_IIF);
|
2013-08-07 13:05:39 +04:00
|
|
|
imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2SR);
|
2010-06-21 11:27:05 +04:00
|
|
|
wake_up(&i2c_imx->queue);
|
2009-01-30 11:32:28 +03:00
|
|
|
return IRQ_HANDLED;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return IRQ_NONE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int i2c_imx_write(struct imx_i2c_struct *i2c_imx, struct i2c_msg *msgs)
|
|
|
|
|
{
|
|
|
|
|
int i, result;
|
|
|
|
|
|
|
|
|
|
dev_dbg(&i2c_imx->adapter.dev, "<%s> write slave address: addr=0x%x\n",
|
|
|
|
|
__func__, msgs->addr << 1);
|
|
|
|
|
|
|
|
|
|
/* write slave address */
|
2013-08-07 13:05:39 +04:00
|
|
|
imx_i2c_write_reg(msgs->addr << 1, i2c_imx, IMX_I2C_I2DR);
|
2009-01-30 11:32:28 +03:00
|
|
|
result = i2c_imx_trx_complete(i2c_imx);
|
|
|
|
|
if (result)
|
|
|
|
|
return result;
|
|
|
|
|
result = i2c_imx_acked(i2c_imx);
|
|
|
|
|
if (result)
|
|
|
|
|
return result;
|
|
|
|
|
dev_dbg(&i2c_imx->adapter.dev, "<%s> write data\n", __func__);
|
|
|
|
|
|
|
|
|
|
/* write data */
|
|
|
|
|
for (i = 0; i < msgs->len; i++) {
|
|
|
|
|
dev_dbg(&i2c_imx->adapter.dev,
|
|
|
|
|
"<%s> write byte: B%d=0x%X\n",
|
|
|
|
|
__func__, i, msgs->buf[i]);
|
2013-08-07 13:05:39 +04:00
|
|
|
imx_i2c_write_reg(msgs->buf[i], i2c_imx, IMX_I2C_I2DR);
|
2009-01-30 11:32:28 +03:00
|
|
|
result = i2c_imx_trx_complete(i2c_imx);
|
|
|
|
|
if (result)
|
|
|
|
|
return result;
|
|
|
|
|
result = i2c_imx_acked(i2c_imx);
|
|
|
|
|
if (result)
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int i2c_imx_read(struct imx_i2c_struct *i2c_imx, struct i2c_msg *msgs)
|
|
|
|
|
{
|
|
|
|
|
int i, result;
|
|
|
|
|
unsigned int temp;
|
|
|
|
|
|
|
|
|
|
dev_dbg(&i2c_imx->adapter.dev,
|
|
|
|
|
"<%s> write slave address: addr=0x%x\n",
|
|
|
|
|
__func__, (msgs->addr << 1) | 0x01);
|
|
|
|
|
|
|
|
|
|
/* write slave address */
|
2013-08-07 13:05:39 +04:00
|
|
|
imx_i2c_write_reg((msgs->addr << 1) | 0x01, i2c_imx, IMX_I2C_I2DR);
|
2009-01-30 11:32:28 +03:00
|
|
|
result = i2c_imx_trx_complete(i2c_imx);
|
|
|
|
|
if (result)
|
|
|
|
|
return result;
|
|
|
|
|
result = i2c_imx_acked(i2c_imx);
|
|
|
|
|
if (result)
|
|
|
|
|
return result;
|
|
|
|
|
|
|
|
|
|
dev_dbg(&i2c_imx->adapter.dev, "<%s> setup bus\n", __func__);
|
|
|
|
|
|
|
|
|
|
/* setup bus to read data */
|
2013-08-07 13:05:39 +04:00
|
|
|
temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR);
|
2009-01-30 11:32:28 +03:00
|
|
|
temp &= ~I2CR_MTX;
|
|
|
|
|
if (msgs->len - 1)
|
|
|
|
|
temp &= ~I2CR_TXAK;
|
2013-08-07 13:05:39 +04:00
|
|
|
imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR);
|
|
|
|
|
imx_i2c_read_reg(i2c_imx, IMX_I2C_I2DR); /* dummy read */
|
2009-01-30 11:32:28 +03:00
|
|
|
|
|
|
|
|
dev_dbg(&i2c_imx->adapter.dev, "<%s> read data\n", __func__);
|
|
|
|
|
|
|
|
|
|
/* read data */
|
|
|
|
|
for (i = 0; i < msgs->len; i++) {
|
|
|
|
|
result = i2c_imx_trx_complete(i2c_imx);
|
|
|
|
|
if (result)
|
|
|
|
|
return result;
|
|
|
|
|
if (i == (msgs->len - 1)) {
|
2009-10-17 13:46:22 +04:00
|
|
|
/* It must generate STOP before read I2DR to prevent
|
|
|
|
|
controller from generating another clock cycle */
|
2009-01-30 11:32:28 +03:00
|
|
|
dev_dbg(&i2c_imx->adapter.dev,
|
|
|
|
|
"<%s> clear MSTA\n", __func__);
|
2013-08-07 13:05:39 +04:00
|
|
|
temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR);
|
2009-10-17 13:46:22 +04:00
|
|
|
temp &= ~(I2CR_MSTA | I2CR_MTX);
|
2013-08-07 13:05:39 +04:00
|
|
|
imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR);
|
2009-10-17 13:46:22 +04:00
|
|
|
i2c_imx_bus_busy(i2c_imx, 0);
|
|
|
|
|
i2c_imx->stopped = 1;
|
2009-01-30 11:32:28 +03:00
|
|
|
} else if (i == (msgs->len - 2)) {
|
|
|
|
|
dev_dbg(&i2c_imx->adapter.dev,
|
|
|
|
|
"<%s> set TXAK\n", __func__);
|
2013-08-07 13:05:39 +04:00
|
|
|
temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR);
|
2009-01-30 11:32:28 +03:00
|
|
|
temp |= I2CR_TXAK;
|
2013-08-07 13:05:39 +04:00
|
|
|
imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR);
|
2009-01-30 11:32:28 +03:00
|
|
|
}
|
2013-08-07 13:05:39 +04:00
|
|
|
msgs->buf[i] = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2DR);
|
2009-01-30 11:32:28 +03:00
|
|
|
dev_dbg(&i2c_imx->adapter.dev,
|
|
|
|
|
"<%s> read byte: B%d=0x%X\n",
|
|
|
|
|
__func__, i, msgs->buf[i]);
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int i2c_imx_xfer(struct i2c_adapter *adapter,
|
|
|
|
|
struct i2c_msg *msgs, int num)
|
|
|
|
|
{
|
|
|
|
|
unsigned int i, temp;
|
|
|
|
|
int result;
|
|
|
|
|
struct imx_i2c_struct *i2c_imx = i2c_get_adapdata(adapter);
|
|
|
|
|
|
|
|
|
|
dev_dbg(&i2c_imx->adapter.dev, "<%s>\n", __func__);
|
|
|
|
|
|
2009-10-17 13:46:22 +04:00
|
|
|
/* Start I2C transfer */
|
|
|
|
|
result = i2c_imx_start(i2c_imx);
|
2009-01-30 11:32:28 +03:00
|
|
|
if (result)
|
|
|
|
|
goto fail0;
|
|
|
|
|
|
|
|
|
|
/* read/write data */
|
|
|
|
|
for (i = 0; i < num; i++) {
|
|
|
|
|
if (i) {
|
|
|
|
|
dev_dbg(&i2c_imx->adapter.dev,
|
|
|
|
|
"<%s> repeated start\n", __func__);
|
2013-08-07 13:05:39 +04:00
|
|
|
temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR);
|
2009-01-30 11:32:28 +03:00
|
|
|
temp |= I2CR_RSTA;
|
2013-08-07 13:05:39 +04:00
|
|
|
imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR);
|
2009-10-17 13:46:22 +04:00
|
|
|
result = i2c_imx_bus_busy(i2c_imx, 1);
|
|
|
|
|
if (result)
|
|
|
|
|
goto fail0;
|
2009-01-30 11:32:28 +03:00
|
|
|
}
|
|
|
|
|
dev_dbg(&i2c_imx->adapter.dev,
|
|
|
|
|
"<%s> transfer message: %d\n", __func__, i);
|
|
|
|
|
/* write/read data */
|
|
|
|
|
#ifdef CONFIG_I2C_DEBUG_BUS
|
2013-08-07 13:05:39 +04:00
|
|
|
temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR);
|
2009-01-30 11:32:28 +03:00
|
|
|
dev_dbg(&i2c_imx->adapter.dev, "<%s> CONTROL: IEN=%d, IIEN=%d, "
|
|
|
|
|
"MSTA=%d, MTX=%d, TXAK=%d, RSTA=%d\n", __func__,
|
|
|
|
|
(temp & I2CR_IEN ? 1 : 0), (temp & I2CR_IIEN ? 1 : 0),
|
|
|
|
|
(temp & I2CR_MSTA ? 1 : 0), (temp & I2CR_MTX ? 1 : 0),
|
|
|
|
|
(temp & I2CR_TXAK ? 1 : 0), (temp & I2CR_RSTA ? 1 : 0));
|
2013-08-07 13:05:39 +04:00
|
|
|
temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2SR);
|
2009-01-30 11:32:28 +03:00
|
|
|
dev_dbg(&i2c_imx->adapter.dev,
|
|
|
|
|
"<%s> STATUS: ICF=%d, IAAS=%d, IBB=%d, "
|
|
|
|
|
"IAL=%d, SRW=%d, IIF=%d, RXAK=%d\n", __func__,
|
|
|
|
|
(temp & I2SR_ICF ? 1 : 0), (temp & I2SR_IAAS ? 1 : 0),
|
|
|
|
|
(temp & I2SR_IBB ? 1 : 0), (temp & I2SR_IAL ? 1 : 0),
|
|
|
|
|
(temp & I2SR_SRW ? 1 : 0), (temp & I2SR_IIF ? 1 : 0),
|
|
|
|
|
(temp & I2SR_RXAK ? 1 : 0));
|
|
|
|
|
#endif
|
|
|
|
|
if (msgs[i].flags & I2C_M_RD)
|
|
|
|
|
result = i2c_imx_read(i2c_imx, &msgs[i]);
|
|
|
|
|
else
|
|
|
|
|
result = i2c_imx_write(i2c_imx, &msgs[i]);
|
2010-03-23 19:28:28 +03:00
|
|
|
if (result)
|
|
|
|
|
goto fail0;
|
2009-01-30 11:32:28 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fail0:
|
|
|
|
|
/* Stop I2C transfer */
|
|
|
|
|
i2c_imx_stop(i2c_imx);
|
|
|
|
|
|
|
|
|
|
dev_dbg(&i2c_imx->adapter.dev, "<%s> exit with: %s: %d\n", __func__,
|
|
|
|
|
(result < 0) ? "error" : "success msg",
|
|
|
|
|
(result < 0) ? result : num);
|
|
|
|
|
return (result < 0) ? result : num;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static u32 i2c_imx_func(struct i2c_adapter *adapter)
|
|
|
|
|
{
|
|
|
|
|
return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct i2c_algorithm i2c_imx_algo = {
|
|
|
|
|
.master_xfer = i2c_imx_xfer,
|
|
|
|
|
.functionality = i2c_imx_func,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static int __init i2c_imx_probe(struct platform_device *pdev)
|
|
|
|
|
{
|
2012-09-14 11:19:00 +04:00
|
|
|
const struct of_device_id *of_id = of_match_device(i2c_imx_dt_ids,
|
|
|
|
|
&pdev->dev);
|
2009-01-30 11:32:28 +03:00
|
|
|
struct imx_i2c_struct *i2c_imx;
|
|
|
|
|
struct resource *res;
|
2013-07-30 11:59:33 +04:00
|
|
|
struct imxi2c_platform_data *pdata = dev_get_platdata(&pdev->dev);
|
2009-01-30 11:32:28 +03:00
|
|
|
void __iomem *base;
|
2012-07-08 15:11:43 +04:00
|
|
|
int irq, ret;
|
|
|
|
|
u32 bitrate;
|
2009-01-30 11:32:28 +03:00
|
|
|
|
|
|
|
|
dev_dbg(&pdev->dev, "<%s>\n", __func__);
|
|
|
|
|
|
|
|
|
|
irq = platform_get_irq(pdev, 0);
|
|
|
|
|
if (irq < 0) {
|
|
|
|
|
dev_err(&pdev->dev, "can't get irq number\n");
|
|
|
|
|
return -ENOENT;
|
|
|
|
|
}
|
|
|
|
|
|
2013-05-10 12:16:54 +04:00
|
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
2013-01-21 14:09:03 +04:00
|
|
|
base = devm_ioremap_resource(&pdev->dev, res);
|
|
|
|
|
if (IS_ERR(base))
|
|
|
|
|
return PTR_ERR(base);
|
2009-01-30 11:32:28 +03:00
|
|
|
|
2012-06-04 15:04:25 +04:00
|
|
|
i2c_imx = devm_kzalloc(&pdev->dev, sizeof(struct imx_i2c_struct),
|
|
|
|
|
GFP_KERNEL);
|
2009-01-30 11:32:28 +03:00
|
|
|
if (!i2c_imx) {
|
|
|
|
|
dev_err(&pdev->dev, "can't allocate interface\n");
|
2012-06-04 15:04:25 +04:00
|
|
|
return -ENOMEM;
|
2009-03-31 15:52:54 +04:00
|
|
|
}
|
|
|
|
|
|
2012-09-14 11:19:00 +04:00
|
|
|
if (of_id)
|
2013-08-07 13:05:42 +04:00
|
|
|
i2c_imx->hwdata = of_id->data;
|
2013-08-07 13:05:38 +04:00
|
|
|
else
|
2013-08-07 13:05:42 +04:00
|
|
|
i2c_imx->hwdata = (struct imx_i2c_hwdata *)
|
|
|
|
|
platform_get_device_id(pdev)->driver_data;
|
2012-09-14 11:19:00 +04:00
|
|
|
|
2009-01-30 11:32:28 +03:00
|
|
|
/* Setup i2c_imx driver structure */
|
2012-04-19 19:31:01 +04:00
|
|
|
strlcpy(i2c_imx->adapter.name, pdev->name, sizeof(i2c_imx->adapter.name));
|
2009-01-30 11:32:28 +03:00
|
|
|
i2c_imx->adapter.owner = THIS_MODULE;
|
|
|
|
|
i2c_imx->adapter.algo = &i2c_imx_algo;
|
|
|
|
|
i2c_imx->adapter.dev.parent = &pdev->dev;
|
|
|
|
|
i2c_imx->adapter.nr = pdev->id;
|
2011-09-08 11:09:35 +04:00
|
|
|
i2c_imx->adapter.dev.of_node = pdev->dev.of_node;
|
2009-01-30 11:32:28 +03:00
|
|
|
i2c_imx->base = base;
|
|
|
|
|
|
|
|
|
|
/* Get I2C clock */
|
2012-07-06 22:31:32 +04:00
|
|
|
i2c_imx->clk = devm_clk_get(&pdev->dev, NULL);
|
2009-01-30 11:32:28 +03:00
|
|
|
if (IS_ERR(i2c_imx->clk)) {
|
|
|
|
|
dev_err(&pdev->dev, "can't get I2C clock\n");
|
2012-06-04 15:04:25 +04:00
|
|
|
return PTR_ERR(i2c_imx->clk);
|
2009-01-30 11:32:28 +03:00
|
|
|
}
|
|
|
|
|
|
2013-08-07 13:05:37 +04:00
|
|
|
ret = clk_prepare_enable(i2c_imx->clk);
|
|
|
|
|
if (ret) {
|
|
|
|
|
dev_err(&pdev->dev, "can't enable I2C clock\n");
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
2009-01-30 11:32:28 +03:00
|
|
|
/* Request IRQ */
|
2012-06-04 15:04:25 +04:00
|
|
|
ret = devm_request_irq(&pdev->dev, irq, i2c_imx_isr, 0,
|
|
|
|
|
pdev->name, i2c_imx);
|
2009-01-30 11:32:28 +03:00
|
|
|
if (ret) {
|
2012-06-04 15:04:25 +04:00
|
|
|
dev_err(&pdev->dev, "can't claim irq %d\n", irq);
|
|
|
|
|
return ret;
|
2009-01-30 11:32:28 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Init queue */
|
|
|
|
|
init_waitqueue_head(&i2c_imx->queue);
|
|
|
|
|
|
|
|
|
|
/* Set up adapter data */
|
|
|
|
|
i2c_set_adapdata(&i2c_imx->adapter, i2c_imx);
|
|
|
|
|
|
|
|
|
|
/* Set up clock divider */
|
2011-09-08 11:09:35 +04:00
|
|
|
bitrate = IMX_I2C_BIT_RATE;
|
|
|
|
|
ret = of_property_read_u32(pdev->dev.of_node,
|
|
|
|
|
"clock-frequency", &bitrate);
|
|
|
|
|
if (ret < 0 && pdata && pdata->bitrate)
|
|
|
|
|
bitrate = pdata->bitrate;
|
|
|
|
|
i2c_imx_set_clk(i2c_imx, bitrate);
|
2009-01-30 11:32:28 +03:00
|
|
|
|
|
|
|
|
/* Set up chip registers to defaults */
|
2013-08-07 13:05:42 +04:00
|
|
|
imx_i2c_write_reg(i2c_imx->hwdata->i2cr_ien_opcode ^ I2CR_IEN,
|
|
|
|
|
i2c_imx, IMX_I2C_I2CR);
|
|
|
|
|
imx_i2c_write_reg(i2c_imx->hwdata->i2sr_clr_opcode, i2c_imx, IMX_I2C_I2SR);
|
2009-01-30 11:32:28 +03:00
|
|
|
|
|
|
|
|
/* Add I2C adapter */
|
|
|
|
|
ret = i2c_add_numbered_adapter(&i2c_imx->adapter);
|
|
|
|
|
if (ret < 0) {
|
|
|
|
|
dev_err(&pdev->dev, "registration failed\n");
|
2012-06-04 15:04:25 +04:00
|
|
|
return ret;
|
2009-01-30 11:32:28 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Set up platform driver data */
|
|
|
|
|
platform_set_drvdata(pdev, i2c_imx);
|
2013-08-07 13:05:37 +04:00
|
|
|
clk_disable_unprepare(i2c_imx->clk);
|
2009-01-30 11:32:28 +03:00
|
|
|
|
2012-06-04 15:04:25 +04:00
|
|
|
dev_dbg(&i2c_imx->adapter.dev, "claimed irq %d\n", irq);
|
2009-01-30 11:32:28 +03:00
|
|
|
dev_dbg(&i2c_imx->adapter.dev, "device resources from 0x%x to 0x%x\n",
|
2012-06-04 15:04:25 +04:00
|
|
|
res->start, res->end);
|
|
|
|
|
dev_dbg(&i2c_imx->adapter.dev, "allocated %d bytes at 0x%x\n",
|
|
|
|
|
resource_size(res), res->start);
|
2009-01-30 11:32:28 +03:00
|
|
|
dev_dbg(&i2c_imx->adapter.dev, "adapter name: \"%s\"\n",
|
|
|
|
|
i2c_imx->adapter.name);
|
2012-08-02 00:38:14 +04:00
|
|
|
dev_info(&i2c_imx->adapter.dev, "IMX I2C adapter registered\n");
|
2009-01-30 11:32:28 +03:00
|
|
|
|
|
|
|
|
return 0; /* Return OK */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int __exit i2c_imx_remove(struct platform_device *pdev)
|
|
|
|
|
{
|
|
|
|
|
struct imx_i2c_struct *i2c_imx = platform_get_drvdata(pdev);
|
|
|
|
|
|
|
|
|
|
/* remove adapter */
|
|
|
|
|
dev_dbg(&i2c_imx->adapter.dev, "adapter removed\n");
|
|
|
|
|
i2c_del_adapter(&i2c_imx->adapter);
|
|
|
|
|
|
|
|
|
|
/* setup chip registers to defaults */
|
2013-08-07 13:05:39 +04:00
|
|
|
imx_i2c_write_reg(0, i2c_imx, IMX_I2C_IADR);
|
|
|
|
|
imx_i2c_write_reg(0, i2c_imx, IMX_I2C_IFDR);
|
|
|
|
|
imx_i2c_write_reg(0, i2c_imx, IMX_I2C_I2CR);
|
|
|
|
|
imx_i2c_write_reg(0, i2c_imx, IMX_I2C_I2SR);
|
2009-01-30 11:32:28 +03:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct platform_driver i2c_imx_driver = {
|
|
|
|
|
.remove = __exit_p(i2c_imx_remove),
|
|
|
|
|
.driver = {
|
|
|
|
|
.name = DRIVER_NAME,
|
|
|
|
|
.owner = THIS_MODULE,
|
2011-09-08 11:09:35 +04:00
|
|
|
.of_match_table = i2c_imx_dt_ids,
|
2012-09-14 11:19:00 +04:00
|
|
|
},
|
|
|
|
|
.id_table = imx_i2c_devtype,
|
2009-01-30 11:32:28 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static int __init i2c_adap_imx_init(void)
|
|
|
|
|
{
|
|
|
|
|
return platform_driver_probe(&i2c_imx_driver, i2c_imx_probe);
|
|
|
|
|
}
|
2009-09-19 11:09:50 +04:00
|
|
|
subsys_initcall(i2c_adap_imx_init);
|
2009-01-30 11:32:28 +03:00
|
|
|
|
|
|
|
|
static void __exit i2c_adap_imx_exit(void)
|
|
|
|
|
{
|
|
|
|
|
platform_driver_unregister(&i2c_imx_driver);
|
|
|
|
|
}
|
|
|
|
|
module_exit(i2c_adap_imx_exit);
|
|
|
|
|
|
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
MODULE_AUTHOR("Darius Augulis");
|
|
|
|
|
MODULE_DESCRIPTION("I2C adapter driver for IMX I2C bus");
|
|
|
|
|
MODULE_ALIAS("platform:" DRIVER_NAME);
|
