2009-06-13 21:51:34 +02:00
|
|
|
/*
|
2012-07-16 13:30:12 +02:00
|
|
|
* Copyright (C) 2007-2012 ST-Ericsson AB
|
2009-06-13 21:51:34 +02:00
|
|
|
* License terms: GNU General Public License (GPL) version 2
|
|
|
|
* ST DDC I2C master mode driver, used in e.g. U300 series platforms.
|
|
|
|
* Author: Linus Walleij <linus.walleij@stericsson.com>
|
|
|
|
* Author: Jonas Aaberg <jonas.aberg@stericsson.com>
|
|
|
|
*/
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/i2c.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/completion.h>
|
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/clk.h>
|
|
|
|
#include <linux/io.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>
|
2009-06-13 21:51:34 +02:00
|
|
|
|
|
|
|
/* the name of this kernel module */
|
|
|
|
#define NAME "stu300"
|
|
|
|
|
|
|
|
/* CR (Control Register) 8bit (R/W) */
|
|
|
|
#define I2C_CR (0x00000000)
|
|
|
|
#define I2C_CR_RESET_VALUE (0x00)
|
|
|
|
#define I2C_CR_RESET_UMASK (0x00)
|
|
|
|
#define I2C_CR_DDC1_ENABLE (0x80)
|
|
|
|
#define I2C_CR_TRANS_ENABLE (0x40)
|
|
|
|
#define I2C_CR_PERIPHERAL_ENABLE (0x20)
|
|
|
|
#define I2C_CR_DDC2B_ENABLE (0x10)
|
|
|
|
#define I2C_CR_START_ENABLE (0x08)
|
|
|
|
#define I2C_CR_ACK_ENABLE (0x04)
|
|
|
|
#define I2C_CR_STOP_ENABLE (0x02)
|
|
|
|
#define I2C_CR_INTERRUPT_ENABLE (0x01)
|
|
|
|
/* SR1 (Status Register 1) 8bit (R/-) */
|
|
|
|
#define I2C_SR1 (0x00000004)
|
|
|
|
#define I2C_SR1_RESET_VALUE (0x00)
|
|
|
|
#define I2C_SR1_RESET_UMASK (0x00)
|
|
|
|
#define I2C_SR1_EVF_IND (0x80)
|
|
|
|
#define I2C_SR1_ADD10_IND (0x40)
|
|
|
|
#define I2C_SR1_TRA_IND (0x20)
|
|
|
|
#define I2C_SR1_BUSY_IND (0x10)
|
|
|
|
#define I2C_SR1_BTF_IND (0x08)
|
|
|
|
#define I2C_SR1_ADSL_IND (0x04)
|
|
|
|
#define I2C_SR1_MSL_IND (0x02)
|
|
|
|
#define I2C_SR1_SB_IND (0x01)
|
|
|
|
/* SR2 (Status Register 2) 8bit (R/-) */
|
|
|
|
#define I2C_SR2 (0x00000008)
|
|
|
|
#define I2C_SR2_RESET_VALUE (0x00)
|
|
|
|
#define I2C_SR2_RESET_UMASK (0x40)
|
|
|
|
#define I2C_SR2_MASK (0xBF)
|
|
|
|
#define I2C_SR2_SCLFAL_IND (0x80)
|
|
|
|
#define I2C_SR2_ENDAD_IND (0x20)
|
|
|
|
#define I2C_SR2_AF_IND (0x10)
|
|
|
|
#define I2C_SR2_STOPF_IND (0x08)
|
|
|
|
#define I2C_SR2_ARLO_IND (0x04)
|
|
|
|
#define I2C_SR2_BERR_IND (0x02)
|
|
|
|
#define I2C_SR2_DDC2BF_IND (0x01)
|
|
|
|
/* CCR (Clock Control Register) 8bit (R/W) */
|
|
|
|
#define I2C_CCR (0x0000000C)
|
|
|
|
#define I2C_CCR_RESET_VALUE (0x00)
|
|
|
|
#define I2C_CCR_RESET_UMASK (0x00)
|
|
|
|
#define I2C_CCR_MASK (0xFF)
|
|
|
|
#define I2C_CCR_FMSM (0x80)
|
|
|
|
#define I2C_CCR_CC_MASK (0x7F)
|
|
|
|
/* OAR1 (Own Address Register 1) 8bit (R/W) */
|
|
|
|
#define I2C_OAR1 (0x00000010)
|
|
|
|
#define I2C_OAR1_RESET_VALUE (0x00)
|
|
|
|
#define I2C_OAR1_RESET_UMASK (0x00)
|
|
|
|
#define I2C_OAR1_ADD_MASK (0xFF)
|
|
|
|
/* OAR2 (Own Address Register 2) 8bit (R/W) */
|
|
|
|
#define I2C_OAR2 (0x00000014)
|
|
|
|
#define I2C_OAR2_RESET_VALUE (0x40)
|
|
|
|
#define I2C_OAR2_RESET_UMASK (0x19)
|
|
|
|
#define I2C_OAR2_MASK (0xE6)
|
|
|
|
#define I2C_OAR2_FR_25_10MHZ (0x00)
|
|
|
|
#define I2C_OAR2_FR_10_1667MHZ (0x20)
|
|
|
|
#define I2C_OAR2_FR_1667_2667MHZ (0x40)
|
|
|
|
#define I2C_OAR2_FR_2667_40MHZ (0x60)
|
|
|
|
#define I2C_OAR2_FR_40_5333MHZ (0x80)
|
|
|
|
#define I2C_OAR2_FR_5333_66MHZ (0xA0)
|
|
|
|
#define I2C_OAR2_FR_66_80MHZ (0xC0)
|
|
|
|
#define I2C_OAR2_FR_80_100MHZ (0xE0)
|
|
|
|
#define I2C_OAR2_FR_MASK (0xE0)
|
|
|
|
#define I2C_OAR2_ADD_MASK (0x06)
|
|
|
|
/* DR (Data Register) 8bit (R/W) */
|
|
|
|
#define I2C_DR (0x00000018)
|
|
|
|
#define I2C_DR_RESET_VALUE (0x00)
|
|
|
|
#define I2C_DR_RESET_UMASK (0xFF)
|
|
|
|
#define I2C_DR_D_MASK (0xFF)
|
|
|
|
/* ECCR (Extended Clock Control Register) 8bit (R/W) */
|
|
|
|
#define I2C_ECCR (0x0000001C)
|
|
|
|
#define I2C_ECCR_RESET_VALUE (0x00)
|
|
|
|
#define I2C_ECCR_RESET_UMASK (0xE0)
|
|
|
|
#define I2C_ECCR_MASK (0x1F)
|
|
|
|
#define I2C_ECCR_CC_MASK (0x1F)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* These events are more or less responses to commands
|
|
|
|
* sent into the hardware, presumably reflecting the state
|
|
|
|
* of an internal state machine.
|
|
|
|
*/
|
|
|
|
enum stu300_event {
|
|
|
|
STU300_EVENT_NONE = 0,
|
|
|
|
STU300_EVENT_1,
|
|
|
|
STU300_EVENT_2,
|
|
|
|
STU300_EVENT_3,
|
|
|
|
STU300_EVENT_4,
|
|
|
|
STU300_EVENT_5,
|
|
|
|
STU300_EVENT_6,
|
|
|
|
STU300_EVENT_7,
|
|
|
|
STU300_EVENT_8,
|
|
|
|
STU300_EVENT_9
|
|
|
|
};
|
|
|
|
|
|
|
|
enum stu300_error {
|
|
|
|
STU300_ERROR_NONE = 0,
|
|
|
|
STU300_ERROR_ACKNOWLEDGE_FAILURE,
|
|
|
|
STU300_ERROR_BUS_ERROR,
|
2009-08-13 22:14:23 +02:00
|
|
|
STU300_ERROR_ARBITRATION_LOST,
|
|
|
|
STU300_ERROR_UNKNOWN
|
2009-06-13 21:51:34 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
/* timeout waiting for the controller to respond */
|
|
|
|
#define STU300_TIMEOUT (msecs_to_jiffies(1000))
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The number of address send athemps tried before giving up.
|
2018-05-31 14:24:02 +02:00
|
|
|
* If the first one fails it seems like 5 to 8 attempts are required.
|
2009-06-13 21:51:34 +02:00
|
|
|
*/
|
2009-08-13 22:14:23 +02:00
|
|
|
#define NUM_ADDR_RESEND_ATTEMPTS 12
|
2009-06-13 21:51:34 +02:00
|
|
|
|
|
|
|
/* I2C clock speed, in Hz 0-400kHz*/
|
|
|
|
static unsigned int scl_frequency = 100000;
|
|
|
|
module_param(scl_frequency, uint, 0644);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct stu300_dev - the stu300 driver state holder
|
|
|
|
* @pdev: parent platform device
|
|
|
|
* @adapter: corresponding I2C adapter
|
|
|
|
* @clk: hardware block clock
|
|
|
|
* @irq: assigned interrupt line
|
|
|
|
* @cmd_issue_lock: this locks the following cmd_ variables
|
|
|
|
* @cmd_complete: acknowledge completion for an I2C command
|
|
|
|
* @cmd_event: expected event coming in as a response to a command
|
|
|
|
* @cmd_err: error code as response to a command
|
|
|
|
* @speed: current bus speed in Hz
|
|
|
|
* @msg_index: index of current message
|
|
|
|
* @msg_len: length of current message
|
|
|
|
*/
|
2009-08-13 22:14:23 +02:00
|
|
|
|
2009-06-13 21:51:34 +02:00
|
|
|
struct stu300_dev {
|
|
|
|
struct platform_device *pdev;
|
|
|
|
struct i2c_adapter adapter;
|
|
|
|
void __iomem *virtbase;
|
|
|
|
struct clk *clk;
|
|
|
|
int irq;
|
|
|
|
spinlock_t cmd_issue_lock;
|
|
|
|
struct completion cmd_complete;
|
|
|
|
enum stu300_event cmd_event;
|
|
|
|
enum stu300_error cmd_err;
|
|
|
|
unsigned int speed;
|
|
|
|
int msg_index;
|
|
|
|
int msg_len;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Local forward function declarations */
|
|
|
|
static int stu300_init_hw(struct stu300_dev *dev);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The block needs writes in both MSW and LSW in order
|
|
|
|
* for all data lines to reach their destination.
|
|
|
|
*/
|
|
|
|
static inline void stu300_wr8(u32 value, void __iomem *address)
|
|
|
|
{
|
|
|
|
writel((value << 16) | value, address);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This merely masks off the duplicates which appear
|
|
|
|
* in bytes 1-3. You _MUST_ use 32-bit bus access on this
|
|
|
|
* device, else it will not work.
|
|
|
|
*/
|
|
|
|
static inline u32 stu300_r8(void __iomem *address)
|
|
|
|
{
|
|
|
|
return readl(address) & 0x000000FFU;
|
|
|
|
}
|
|
|
|
|
2009-08-13 22:14:23 +02:00
|
|
|
static void stu300_irq_enable(struct stu300_dev *dev)
|
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
val = stu300_r8(dev->virtbase + I2C_CR);
|
|
|
|
val |= I2C_CR_INTERRUPT_ENABLE;
|
|
|
|
/* Twice paranoia (possible HW glitch) */
|
|
|
|
stu300_wr8(val, dev->virtbase + I2C_CR);
|
|
|
|
stu300_wr8(val, dev->virtbase + I2C_CR);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void stu300_irq_disable(struct stu300_dev *dev)
|
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
val = stu300_r8(dev->virtbase + I2C_CR);
|
|
|
|
val &= ~I2C_CR_INTERRUPT_ENABLE;
|
|
|
|
/* Twice paranoia (possible HW glitch) */
|
|
|
|
stu300_wr8(val, dev->virtbase + I2C_CR);
|
|
|
|
stu300_wr8(val, dev->virtbase + I2C_CR);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-06-13 21:51:34 +02:00
|
|
|
/*
|
|
|
|
* Tells whether a certain event or events occurred in
|
|
|
|
* response to a command. The events represent states in
|
|
|
|
* the internal state machine of the hardware. The events
|
|
|
|
* are not very well described in the hardware
|
|
|
|
* documentation and can only be treated as abstract state
|
|
|
|
* machine states.
|
|
|
|
*
|
2009-08-13 22:14:23 +02:00
|
|
|
* @ret 0 = event has not occurred or unknown error, any
|
|
|
|
* other value means the correct event occurred or an error.
|
2009-06-13 21:51:34 +02:00
|
|
|
*/
|
2009-08-13 22:14:23 +02:00
|
|
|
|
2009-06-13 21:51:34 +02:00
|
|
|
static int stu300_event_occurred(struct stu300_dev *dev,
|
|
|
|
enum stu300_event mr_event) {
|
|
|
|
u32 status1;
|
|
|
|
u32 status2;
|
|
|
|
|
|
|
|
/* What event happened? */
|
|
|
|
status1 = stu300_r8(dev->virtbase + I2C_SR1);
|
2009-08-13 22:14:23 +02:00
|
|
|
|
2009-06-13 21:51:34 +02:00
|
|
|
if (!(status1 & I2C_SR1_EVF_IND))
|
|
|
|
/* No event at all */
|
|
|
|
return 0;
|
2009-08-13 22:14:23 +02:00
|
|
|
|
2009-06-13 21:51:34 +02:00
|
|
|
status2 = stu300_r8(dev->virtbase + I2C_SR2);
|
|
|
|
|
2009-08-13 22:14:23 +02:00
|
|
|
/* Block any multiple interrupts */
|
|
|
|
stu300_irq_disable(dev);
|
|
|
|
|
|
|
|
/* Check for errors first */
|
|
|
|
if (status2 & I2C_SR2_AF_IND) {
|
|
|
|
dev->cmd_err = STU300_ERROR_ACKNOWLEDGE_FAILURE;
|
|
|
|
return 1;
|
|
|
|
} else if (status2 & I2C_SR2_BERR_IND) {
|
|
|
|
dev->cmd_err = STU300_ERROR_BUS_ERROR;
|
|
|
|
return 1;
|
|
|
|
} else if (status2 & I2C_SR2_ARLO_IND) {
|
|
|
|
dev->cmd_err = STU300_ERROR_ARBITRATION_LOST;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2009-06-13 21:51:34 +02:00
|
|
|
switch (mr_event) {
|
|
|
|
case STU300_EVENT_1:
|
|
|
|
if (status1 & I2C_SR1_ADSL_IND)
|
|
|
|
return 1;
|
|
|
|
break;
|
|
|
|
case STU300_EVENT_2:
|
|
|
|
case STU300_EVENT_3:
|
|
|
|
case STU300_EVENT_7:
|
|
|
|
case STU300_EVENT_8:
|
|
|
|
if (status1 & I2C_SR1_BTF_IND) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case STU300_EVENT_4:
|
|
|
|
if (status2 & I2C_SR2_STOPF_IND)
|
|
|
|
return 1;
|
|
|
|
break;
|
|
|
|
case STU300_EVENT_5:
|
|
|
|
if (status1 & I2C_SR1_SB_IND)
|
|
|
|
/* Clear start bit */
|
|
|
|
return 1;
|
|
|
|
break;
|
|
|
|
case STU300_EVENT_6:
|
|
|
|
if (status2 & I2C_SR2_ENDAD_IND) {
|
|
|
|
/* First check for any errors */
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case STU300_EVENT_9:
|
|
|
|
if (status1 & I2C_SR1_ADD10_IND)
|
|
|
|
return 1;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2009-08-13 22:14:23 +02:00
|
|
|
/* If we get here, we're on thin ice.
|
|
|
|
* Here we are in a status where we have
|
|
|
|
* gotten a response that does not match
|
|
|
|
* what we requested.
|
|
|
|
*/
|
|
|
|
dev->cmd_err = STU300_ERROR_UNKNOWN;
|
|
|
|
dev_err(&dev->pdev->dev,
|
|
|
|
"Unhandled interrupt! %d sr1: 0x%x sr2: 0x%x\n",
|
|
|
|
mr_event, status1, status2);
|
2009-06-13 21:51:34 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static irqreturn_t stu300_irh(int irq, void *data)
|
|
|
|
{
|
|
|
|
struct stu300_dev *dev = data;
|
|
|
|
int res;
|
|
|
|
|
2009-08-13 22:14:23 +02:00
|
|
|
/* Just make sure that the block is clocked */
|
|
|
|
clk_enable(dev->clk);
|
|
|
|
|
2009-06-13 21:51:34 +02:00
|
|
|
/* See if this was what we were waiting for */
|
|
|
|
spin_lock(&dev->cmd_issue_lock);
|
2009-08-13 22:14:23 +02:00
|
|
|
|
|
|
|
res = stu300_event_occurred(dev, dev->cmd_event);
|
|
|
|
if (res || dev->cmd_err != STU300_ERROR_NONE)
|
|
|
|
complete(&dev->cmd_complete);
|
|
|
|
|
2009-06-13 21:51:34 +02:00
|
|
|
spin_unlock(&dev->cmd_issue_lock);
|
2009-08-13 22:14:23 +02:00
|
|
|
|
|
|
|
clk_disable(dev->clk);
|
|
|
|
|
2009-06-13 21:51:34 +02:00
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Sends a command and then waits for the bits masked by *flagmask*
|
|
|
|
* to go high or low by IRQ awaiting.
|
|
|
|
*/
|
|
|
|
static int stu300_start_and_await_event(struct stu300_dev *dev,
|
|
|
|
u8 cr_value,
|
|
|
|
enum stu300_event mr_event)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (unlikely(irqs_disabled())) {
|
|
|
|
/* TODO: implement polling for this case if need be. */
|
|
|
|
WARN(1, "irqs are disabled, cannot poll for event\n");
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Lock command issue, fill in an event we wait for */
|
|
|
|
spin_lock_irq(&dev->cmd_issue_lock);
|
|
|
|
init_completion(&dev->cmd_complete);
|
|
|
|
dev->cmd_err = STU300_ERROR_NONE;
|
|
|
|
dev->cmd_event = mr_event;
|
|
|
|
spin_unlock_irq(&dev->cmd_issue_lock);
|
|
|
|
|
|
|
|
/* Turn on interrupt, send command and wait. */
|
|
|
|
cr_value |= I2C_CR_INTERRUPT_ENABLE;
|
|
|
|
stu300_wr8(cr_value, dev->virtbase + I2C_CR);
|
|
|
|
ret = wait_for_completion_interruptible_timeout(&dev->cmd_complete,
|
|
|
|
STU300_TIMEOUT);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(&dev->pdev->dev,
|
|
|
|
"wait_for_completion_interruptible_timeout() "
|
|
|
|
"returned %d waiting for event %04x\n", ret, mr_event);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret == 0) {
|
|
|
|
dev_err(&dev->pdev->dev, "controller timed out "
|
|
|
|
"waiting for event %d, reinit hardware\n", mr_event);
|
|
|
|
(void) stu300_init_hw(dev);
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dev->cmd_err != STU300_ERROR_NONE) {
|
|
|
|
dev_err(&dev->pdev->dev, "controller (start) "
|
|
|
|
"error %d waiting for event %d, reinit hardware\n",
|
|
|
|
dev->cmd_err, mr_event);
|
|
|
|
(void) stu300_init_hw(dev);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This waits for a flag to be set, if it is not set on entry, an interrupt is
|
|
|
|
* configured to wait for the flag using a completion.
|
|
|
|
*/
|
|
|
|
static int stu300_await_event(struct stu300_dev *dev,
|
|
|
|
enum stu300_event mr_event)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (unlikely(irqs_disabled())) {
|
|
|
|
/* TODO: implement polling for this case if need be. */
|
|
|
|
dev_err(&dev->pdev->dev, "irqs are disabled on this "
|
|
|
|
"system!\n");
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Is it already here? */
|
|
|
|
spin_lock_irq(&dev->cmd_issue_lock);
|
|
|
|
dev->cmd_err = STU300_ERROR_NONE;
|
|
|
|
dev->cmd_event = mr_event;
|
|
|
|
|
2009-08-13 22:14:23 +02:00
|
|
|
init_completion(&dev->cmd_complete);
|
2009-06-13 21:51:34 +02:00
|
|
|
|
2009-08-13 22:14:23 +02:00
|
|
|
/* Turn on the I2C interrupt for current operation */
|
|
|
|
stu300_irq_enable(dev);
|
2009-06-13 21:51:34 +02:00
|
|
|
|
|
|
|
/* Unlock the command block and wait for the event to occur */
|
|
|
|
spin_unlock_irq(&dev->cmd_issue_lock);
|
2009-08-13 22:14:23 +02:00
|
|
|
|
2009-06-13 21:51:34 +02:00
|
|
|
ret = wait_for_completion_interruptible_timeout(&dev->cmd_complete,
|
|
|
|
STU300_TIMEOUT);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(&dev->pdev->dev,
|
|
|
|
"wait_for_completion_interruptible_timeout()"
|
|
|
|
"returned %d waiting for event %04x\n", ret, mr_event);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret == 0) {
|
|
|
|
if (mr_event != STU300_EVENT_6) {
|
|
|
|
dev_err(&dev->pdev->dev, "controller "
|
|
|
|
"timed out waiting for event %d, reinit "
|
|
|
|
"hardware\n", mr_event);
|
|
|
|
(void) stu300_init_hw(dev);
|
|
|
|
}
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dev->cmd_err != STU300_ERROR_NONE) {
|
|
|
|
if (mr_event != STU300_EVENT_6) {
|
|
|
|
dev_err(&dev->pdev->dev, "controller "
|
|
|
|
"error (await_event) %d waiting for event %d, "
|
|
|
|
"reinit hardware\n", dev->cmd_err, mr_event);
|
|
|
|
(void) stu300_init_hw(dev);
|
|
|
|
}
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Waits for the busy bit to go low by repeated polling.
|
|
|
|
*/
|
|
|
|
#define BUSY_RELEASE_ATTEMPTS 10
|
|
|
|
static int stu300_wait_while_busy(struct stu300_dev *dev)
|
|
|
|
{
|
|
|
|
unsigned long timeout;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < BUSY_RELEASE_ATTEMPTS; i++) {
|
|
|
|
timeout = jiffies + STU300_TIMEOUT;
|
|
|
|
|
|
|
|
while (!time_after(jiffies, timeout)) {
|
|
|
|
/* Is not busy? */
|
|
|
|
if ((stu300_r8(dev->virtbase + I2C_SR1) &
|
|
|
|
I2C_SR1_BUSY_IND) == 0)
|
|
|
|
return 0;
|
|
|
|
msleep(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_err(&dev->pdev->dev, "transaction timed out "
|
|
|
|
"waiting for device to be free (not busy). "
|
|
|
|
"Attempt: %d\n", i+1);
|
|
|
|
|
|
|
|
dev_err(&dev->pdev->dev, "base address = "
|
|
|
|
"0x%08x, reinit hardware\n", (u32) dev->virtbase);
|
|
|
|
|
|
|
|
(void) stu300_init_hw(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_err(&dev->pdev->dev, "giving up after %d attempts "
|
|
|
|
"to reset the bus.\n", BUSY_RELEASE_ATTEMPTS);
|
|
|
|
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct stu300_clkset {
|
|
|
|
unsigned long rate;
|
|
|
|
u32 setting;
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct stu300_clkset stu300_clktable[] = {
|
2009-08-13 22:14:23 +02:00
|
|
|
{ 0, 0xFFU },
|
|
|
|
{ 2500000, I2C_OAR2_FR_25_10MHZ },
|
|
|
|
{ 10000000, I2C_OAR2_FR_10_1667MHZ },
|
|
|
|
{ 16670000, I2C_OAR2_FR_1667_2667MHZ },
|
|
|
|
{ 26670000, I2C_OAR2_FR_2667_40MHZ },
|
|
|
|
{ 40000000, I2C_OAR2_FR_40_5333MHZ },
|
|
|
|
{ 53330000, I2C_OAR2_FR_5333_66MHZ },
|
|
|
|
{ 66000000, I2C_OAR2_FR_66_80MHZ },
|
|
|
|
{ 80000000, I2C_OAR2_FR_80_100MHZ },
|
2009-06-13 21:51:34 +02:00
|
|
|
{ 100000000, 0xFFU },
|
|
|
|
};
|
|
|
|
|
2009-08-13 22:14:23 +02:00
|
|
|
|
2009-06-13 21:51:34 +02:00
|
|
|
static int stu300_set_clk(struct stu300_dev *dev, unsigned long clkrate)
|
|
|
|
{
|
|
|
|
|
|
|
|
u32 val;
|
|
|
|
int i = 0;
|
|
|
|
|
2011-03-31 03:57:33 +02:00
|
|
|
/* Locate the appropriate clock setting */
|
2010-04-07 11:22:58 +02:00
|
|
|
while (i < ARRAY_SIZE(stu300_clktable) - 1 &&
|
2009-06-13 21:51:34 +02:00
|
|
|
stu300_clktable[i].rate < clkrate)
|
|
|
|
i++;
|
|
|
|
|
|
|
|
if (stu300_clktable[i].setting == 0xFFU) {
|
|
|
|
dev_err(&dev->pdev->dev, "too %s clock rate requested "
|
|
|
|
"(%lu Hz).\n", i ? "high" : "low", clkrate);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
stu300_wr8(stu300_clktable[i].setting,
|
|
|
|
dev->virtbase + I2C_OAR2);
|
|
|
|
|
|
|
|
dev_dbg(&dev->pdev->dev, "Clock rate %lu Hz, I2C bus speed %d Hz "
|
|
|
|
"virtbase %p\n", clkrate, dev->speed, dev->virtbase);
|
|
|
|
|
|
|
|
if (dev->speed > 100000)
|
|
|
|
/* Fast Mode I2C */
|
2009-08-13 22:14:23 +02:00
|
|
|
val = ((clkrate/dev->speed) - 9)/3 + 1;
|
2009-06-13 21:51:34 +02:00
|
|
|
else
|
|
|
|
/* Standard Mode I2C */
|
2009-08-13 22:14:23 +02:00
|
|
|
val = ((clkrate/dev->speed) - 7)/2 + 1;
|
2009-06-13 21:51:34 +02:00
|
|
|
|
|
|
|
/* According to spec the divider must be > 2 */
|
|
|
|
if (val < 0x002) {
|
|
|
|
dev_err(&dev->pdev->dev, "too low clock rate (%lu Hz).\n",
|
|
|
|
clkrate);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We have 12 bits clock divider only! */
|
|
|
|
if (val & 0xFFFFF000U) {
|
|
|
|
dev_err(&dev->pdev->dev, "too high clock rate (%lu Hz).\n",
|
|
|
|
clkrate);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dev->speed > 100000) {
|
|
|
|
/* CC6..CC0 */
|
|
|
|
stu300_wr8((val & I2C_CCR_CC_MASK) | I2C_CCR_FMSM,
|
|
|
|
dev->virtbase + I2C_CCR);
|
|
|
|
dev_dbg(&dev->pdev->dev, "set clock divider to 0x%08x, "
|
|
|
|
"Fast Mode I2C\n", val);
|
|
|
|
} else {
|
|
|
|
/* CC6..CC0 */
|
|
|
|
stu300_wr8((val & I2C_CCR_CC_MASK),
|
|
|
|
dev->virtbase + I2C_CCR);
|
|
|
|
dev_dbg(&dev->pdev->dev, "set clock divider to "
|
|
|
|
"0x%08x, Standard Mode I2C\n", val);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* CC11..CC7 */
|
|
|
|
stu300_wr8(((val >> 7) & 0x1F),
|
|
|
|
dev->virtbase + I2C_ECCR);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int stu300_init_hw(struct stu300_dev *dev)
|
|
|
|
{
|
|
|
|
u32 dummy;
|
|
|
|
unsigned long clkrate;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* Disable controller */
|
|
|
|
stu300_wr8(0x00, dev->virtbase + I2C_CR);
|
|
|
|
/*
|
|
|
|
* Set own address to some default value (0x00).
|
|
|
|
* We do not support slave mode anyway.
|
|
|
|
*/
|
|
|
|
stu300_wr8(0x00, dev->virtbase + I2C_OAR1);
|
|
|
|
/*
|
|
|
|
* The I2C controller only operates properly in 26 MHz but we
|
|
|
|
* program this driver as if we didn't know. This will also set the two
|
|
|
|
* high bits of the own address to zero as well.
|
|
|
|
* There is no known hardware issue with running in 13 MHz
|
|
|
|
* However, speeds over 200 kHz are not used.
|
|
|
|
*/
|
|
|
|
clkrate = clk_get_rate(dev->clk);
|
|
|
|
ret = stu300_set_clk(dev, clkrate);
|
2009-08-13 22:14:23 +02:00
|
|
|
|
2009-06-13 21:51:34 +02:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
/*
|
|
|
|
* Enable block, do it TWICE (hardware glitch)
|
|
|
|
* Setting bit 7 can enable DDC mode. (Not used currently.)
|
|
|
|
*/
|
|
|
|
stu300_wr8(I2C_CR_PERIPHERAL_ENABLE,
|
|
|
|
dev->virtbase + I2C_CR);
|
|
|
|
stu300_wr8(I2C_CR_PERIPHERAL_ENABLE,
|
|
|
|
dev->virtbase + I2C_CR);
|
|
|
|
/* Make a dummy read of the status register SR1 & SR2 */
|
|
|
|
dummy = stu300_r8(dev->virtbase + I2C_SR2);
|
|
|
|
dummy = stu300_r8(dev->virtbase + I2C_SR1);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Send slave address. */
|
|
|
|
static int stu300_send_address(struct stu300_dev *dev,
|
|
|
|
struct i2c_msg *msg, int resend)
|
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
int ret;
|
|
|
|
|
2018-05-16 09:16:47 +02:00
|
|
|
if (msg->flags & I2C_M_TEN) {
|
2009-06-13 21:51:34 +02:00
|
|
|
/* This is probably how 10 bit addresses look */
|
|
|
|
val = (0xf0 | (((u32) msg->addr & 0x300) >> 7)) &
|
|
|
|
I2C_DR_D_MASK;
|
2018-05-16 09:16:47 +02:00
|
|
|
if (msg->flags & I2C_M_RD)
|
|
|
|
/* This is the direction bit */
|
|
|
|
val |= 0x01;
|
|
|
|
} else {
|
|
|
|
val = i2c_8bit_addr_from_msg(msg);
|
|
|
|
}
|
2009-06-13 21:51:34 +02:00
|
|
|
|
2018-05-16 09:16:47 +02:00
|
|
|
if (resend) {
|
|
|
|
if (msg->flags & I2C_M_RD)
|
2009-06-13 21:51:34 +02:00
|
|
|
dev_dbg(&dev->pdev->dev, "read resend\n");
|
2018-05-16 09:16:47 +02:00
|
|
|
else
|
|
|
|
dev_dbg(&dev->pdev->dev, "write resend\n");
|
|
|
|
}
|
|
|
|
|
2009-06-13 21:51:34 +02:00
|
|
|
stu300_wr8(val, dev->virtbase + I2C_DR);
|
|
|
|
|
|
|
|
/* For 10bit addressing, await 10bit request (EVENT 9) */
|
|
|
|
if (msg->flags & I2C_M_TEN) {
|
|
|
|
ret = stu300_await_event(dev, STU300_EVENT_9);
|
|
|
|
/*
|
|
|
|
* The slave device wants a 10bit address, send the rest
|
|
|
|
* of the bits (the LSBits)
|
|
|
|
*/
|
|
|
|
val = msg->addr & I2C_DR_D_MASK;
|
|
|
|
/* This clears "event 9" */
|
|
|
|
stu300_wr8(val, dev->virtbase + I2C_DR);
|
|
|
|
if (ret != 0)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
/* FIXME: Why no else here? two events for 10bit?
|
|
|
|
* Await event 6 (normal) or event 9 (10bit)
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (resend)
|
|
|
|
dev_dbg(&dev->pdev->dev, "await event 6\n");
|
|
|
|
ret = stu300_await_event(dev, STU300_EVENT_6);
|
|
|
|
|
|
|
|
/*
|
2011-03-31 03:57:33 +02:00
|
|
|
* Clear any pending EVENT 6 no matter what happened during
|
2009-06-13 21:51:34 +02:00
|
|
|
* await_event.
|
|
|
|
*/
|
|
|
|
val = stu300_r8(dev->virtbase + I2C_CR);
|
|
|
|
val |= I2C_CR_PERIPHERAL_ENABLE;
|
|
|
|
stu300_wr8(val, dev->virtbase + I2C_CR);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int stu300_xfer_msg(struct i2c_adapter *adap,
|
|
|
|
struct i2c_msg *msg, int stop)
|
|
|
|
{
|
|
|
|
u32 cr;
|
|
|
|
u32 val;
|
|
|
|
u32 i;
|
|
|
|
int ret;
|
|
|
|
int attempts = 0;
|
|
|
|
struct stu300_dev *dev = i2c_get_adapdata(adap);
|
|
|
|
|
|
|
|
clk_enable(dev->clk);
|
|
|
|
|
|
|
|
/* Remove this if (0) to trace each and every message. */
|
|
|
|
if (0) {
|
|
|
|
dev_dbg(&dev->pdev->dev, "I2C message to: 0x%04x, len: %d, "
|
|
|
|
"flags: 0x%04x, stop: %d\n",
|
|
|
|
msg->addr, msg->len, msg->flags, stop);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Zero-length messages are not supported by this hardware */
|
|
|
|
if (msg->len == 0) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto exit_disable;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For some reason, sending the address sometimes fails when running
|
|
|
|
* on the 13 MHz clock. No interrupt arrives. This is a work around,
|
|
|
|
* which tries to restart and send the address up to 10 times before
|
|
|
|
* really giving up. Usually 5 to 8 attempts are enough.
|
|
|
|
*/
|
|
|
|
do {
|
|
|
|
if (attempts)
|
|
|
|
dev_dbg(&dev->pdev->dev, "wait while busy\n");
|
|
|
|
/* Check that the bus is free, or wait until some timeout */
|
|
|
|
ret = stu300_wait_while_busy(dev);
|
|
|
|
if (ret != 0)
|
|
|
|
goto exit_disable;
|
|
|
|
|
|
|
|
if (attempts)
|
|
|
|
dev_dbg(&dev->pdev->dev, "re-int hw\n");
|
|
|
|
/*
|
|
|
|
* According to ST, there is no problem if the clock is
|
|
|
|
* changed between 13 and 26 MHz during a transfer.
|
|
|
|
*/
|
|
|
|
ret = stu300_init_hw(dev);
|
|
|
|
if (ret)
|
|
|
|
goto exit_disable;
|
|
|
|
|
|
|
|
/* Send a start condition */
|
|
|
|
cr = I2C_CR_PERIPHERAL_ENABLE;
|
|
|
|
/* Setting the START bit puts the block in master mode */
|
|
|
|
if (!(msg->flags & I2C_M_NOSTART))
|
|
|
|
cr |= I2C_CR_START_ENABLE;
|
|
|
|
if ((msg->flags & I2C_M_RD) && (msg->len > 1))
|
|
|
|
/* On read more than 1 byte, we need ack. */
|
|
|
|
cr |= I2C_CR_ACK_ENABLE;
|
|
|
|
/* Check that it gets through */
|
|
|
|
if (!(msg->flags & I2C_M_NOSTART)) {
|
|
|
|
if (attempts)
|
|
|
|
dev_dbg(&dev->pdev->dev, "send start event\n");
|
|
|
|
ret = stu300_start_and_await_event(dev, cr,
|
|
|
|
STU300_EVENT_5);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (attempts)
|
|
|
|
dev_dbg(&dev->pdev->dev, "send address\n");
|
|
|
|
|
|
|
|
if (ret == 0)
|
|
|
|
/* Send address */
|
|
|
|
ret = stu300_send_address(dev, msg, attempts != 0);
|
|
|
|
|
|
|
|
if (ret != 0) {
|
|
|
|
attempts++;
|
|
|
|
dev_dbg(&dev->pdev->dev, "failed sending address, "
|
|
|
|
"retrying. Attempt: %d msg_index: %d/%d\n",
|
|
|
|
attempts, dev->msg_index, dev->msg_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
} while (ret != 0 && attempts < NUM_ADDR_RESEND_ATTEMPTS);
|
|
|
|
|
|
|
|
if (attempts < NUM_ADDR_RESEND_ATTEMPTS && attempts > 0) {
|
|
|
|
dev_dbg(&dev->pdev->dev, "managed to get address "
|
2009-08-13 22:14:23 +02:00
|
|
|
"through after %d attempts\n", attempts);
|
2009-06-13 21:51:34 +02:00
|
|
|
} else if (attempts == NUM_ADDR_RESEND_ATTEMPTS) {
|
|
|
|
dev_dbg(&dev->pdev->dev, "I give up, tried %d times "
|
2009-08-13 22:14:23 +02:00
|
|
|
"to resend address.\n",
|
|
|
|
NUM_ADDR_RESEND_ATTEMPTS);
|
2009-06-13 21:51:34 +02:00
|
|
|
goto exit_disable;
|
|
|
|
}
|
|
|
|
|
2009-08-13 22:14:23 +02:00
|
|
|
|
2009-06-13 21:51:34 +02:00
|
|
|
if (msg->flags & I2C_M_RD) {
|
|
|
|
/* READ: we read the actual bytes one at a time */
|
|
|
|
for (i = 0; i < msg->len; i++) {
|
|
|
|
if (i == msg->len-1) {
|
|
|
|
/*
|
|
|
|
* Disable ACK and set STOP condition before
|
|
|
|
* reading last byte
|
|
|
|
*/
|
|
|
|
val = I2C_CR_PERIPHERAL_ENABLE;
|
|
|
|
|
|
|
|
if (stop)
|
|
|
|
val |= I2C_CR_STOP_ENABLE;
|
|
|
|
|
|
|
|
stu300_wr8(val,
|
|
|
|
dev->virtbase + I2C_CR);
|
|
|
|
}
|
|
|
|
/* Wait for this byte... */
|
|
|
|
ret = stu300_await_event(dev, STU300_EVENT_7);
|
|
|
|
if (ret != 0)
|
|
|
|
goto exit_disable;
|
|
|
|
/* This clears event 7 */
|
|
|
|
msg->buf[i] = (u8) stu300_r8(dev->virtbase + I2C_DR);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* WRITE: we send the actual bytes one at a time */
|
|
|
|
for (i = 0; i < msg->len; i++) {
|
|
|
|
/* Write the byte */
|
|
|
|
stu300_wr8(msg->buf[i],
|
|
|
|
dev->virtbase + I2C_DR);
|
|
|
|
/* Check status */
|
|
|
|
ret = stu300_await_event(dev, STU300_EVENT_8);
|
|
|
|
/* Next write to DR will clear event 8 */
|
|
|
|
if (ret != 0) {
|
|
|
|
dev_err(&dev->pdev->dev, "error awaiting "
|
|
|
|
"event 8 (%d)\n", ret);
|
|
|
|
goto exit_disable;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Check NAK */
|
|
|
|
if (!(msg->flags & I2C_M_IGNORE_NAK)) {
|
|
|
|
if (stu300_r8(dev->virtbase + I2C_SR2) &
|
|
|
|
I2C_SR2_AF_IND) {
|
|
|
|
dev_err(&dev->pdev->dev, "I2C payload "
|
|
|
|
"send returned NAK!\n");
|
|
|
|
ret = -EIO;
|
|
|
|
goto exit_disable;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (stop) {
|
|
|
|
/* Send stop condition */
|
|
|
|
val = I2C_CR_PERIPHERAL_ENABLE;
|
|
|
|
val |= I2C_CR_STOP_ENABLE;
|
|
|
|
stu300_wr8(val, dev->virtbase + I2C_CR);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check that the bus is free, or wait until some timeout occurs */
|
|
|
|
ret = stu300_wait_while_busy(dev);
|
|
|
|
if (ret != 0) {
|
2014-01-07 13:58:06 +01:00
|
|
|
dev_err(&dev->pdev->dev, "timeout waiting for transfer "
|
2009-06-13 21:51:34 +02:00
|
|
|
"to commence.\n");
|
|
|
|
goto exit_disable;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Dummy read status registers */
|
|
|
|
val = stu300_r8(dev->virtbase + I2C_SR2);
|
|
|
|
val = stu300_r8(dev->virtbase + I2C_SR1);
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
exit_disable:
|
|
|
|
/* Disable controller */
|
|
|
|
stu300_wr8(0x00, dev->virtbase + I2C_CR);
|
|
|
|
clk_disable(dev->clk);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int stu300_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs,
|
|
|
|
int num)
|
|
|
|
{
|
|
|
|
int ret = -1;
|
|
|
|
int i;
|
2009-08-13 22:14:23 +02:00
|
|
|
|
2009-06-13 21:51:34 +02:00
|
|
|
struct stu300_dev *dev = i2c_get_adapdata(adap);
|
|
|
|
dev->msg_len = num;
|
2009-08-13 22:14:23 +02:00
|
|
|
|
2009-06-13 21:51:34 +02:00
|
|
|
for (i = 0; i < num; i++) {
|
|
|
|
/*
|
|
|
|
* Another driver appears to send stop for each message,
|
|
|
|
* here we only do that for the last message. Possibly some
|
|
|
|
* peripherals require this behaviour, then their drivers
|
|
|
|
* have to send single messages in order to get "stop" for
|
|
|
|
* each message.
|
|
|
|
*/
|
|
|
|
dev->msg_index = i;
|
|
|
|
|
|
|
|
ret = stu300_xfer_msg(adap, &msgs[i], (i == (num - 1)));
|
2009-08-13 22:14:23 +02:00
|
|
|
|
2009-06-13 21:51:34 +02:00
|
|
|
if (ret != 0) {
|
|
|
|
num = ret;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return num;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32 stu300_func(struct i2c_adapter *adap)
|
|
|
|
{
|
|
|
|
/* This is the simplest thing you can think of... */
|
|
|
|
return I2C_FUNC_I2C | I2C_FUNC_10BIT_ADDR;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct i2c_algorithm stu300_algo = {
|
|
|
|
.master_xfer = stu300_xfer,
|
|
|
|
.functionality = stu300_func,
|
|
|
|
};
|
|
|
|
|
2013-10-08 22:35:36 +02:00
|
|
|
static int stu300_probe(struct platform_device *pdev)
|
2009-06-13 21:51:34 +02:00
|
|
|
{
|
|
|
|
struct stu300_dev *dev;
|
|
|
|
struct i2c_adapter *adap;
|
|
|
|
struct resource *res;
|
|
|
|
int bus_nr;
|
|
|
|
int ret = 0;
|
|
|
|
|
2012-07-16 13:30:12 +02:00
|
|
|
dev = devm_kzalloc(&pdev->dev, sizeof(struct stu300_dev), GFP_KERNEL);
|
2014-05-13 03:51:58 +02:00
|
|
|
if (!dev)
|
2012-07-16 13:30:12 +02:00
|
|
|
return -ENOMEM;
|
2009-06-13 21:51:34 +02:00
|
|
|
|
|
|
|
bus_nr = pdev->id;
|
2013-05-23 15:26:29 +02:00
|
|
|
dev->clk = devm_clk_get(&pdev->dev, NULL);
|
2009-06-13 21:51:34 +02:00
|
|
|
if (IS_ERR(dev->clk)) {
|
|
|
|
dev_err(&pdev->dev, "could not retrieve i2c bus clock\n");
|
2012-07-16 13:30:12 +02:00
|
|
|
return PTR_ERR(dev->clk);
|
2009-06-13 21:51:34 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
dev->pdev = pdev;
|
|
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
2013-01-21 11:09:03 +01:00
|
|
|
dev->virtbase = devm_ioremap_resource(&pdev->dev, res);
|
2009-06-13 21:51:34 +02:00
|
|
|
dev_dbg(&pdev->dev, "initialize bus device I2C%d on virtual "
|
|
|
|
"base %p\n", bus_nr, dev->virtbase);
|
2013-01-21 11:09:03 +01:00
|
|
|
if (IS_ERR(dev->virtbase))
|
|
|
|
return PTR_ERR(dev->virtbase);
|
2009-06-13 21:51:34 +02:00
|
|
|
|
|
|
|
dev->irq = platform_get_irq(pdev, 0);
|
2012-07-16 13:30:12 +02:00
|
|
|
ret = devm_request_irq(&pdev->dev, dev->irq, stu300_irh, 0, NAME, dev);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2009-06-13 21:51:34 +02:00
|
|
|
|
|
|
|
dev->speed = scl_frequency;
|
|
|
|
|
2012-06-12 19:33:30 +02:00
|
|
|
clk_prepare_enable(dev->clk);
|
2009-06-13 21:51:34 +02:00
|
|
|
ret = stu300_init_hw(dev);
|
|
|
|
clk_disable(dev->clk);
|
|
|
|
if (ret != 0) {
|
|
|
|
dev_err(&dev->pdev->dev, "error initializing hardware.\n");
|
2012-07-16 13:30:12 +02:00
|
|
|
return -EIO;
|
2009-06-13 21:51:34 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* IRQ event handling initialization */
|
|
|
|
spin_lock_init(&dev->cmd_issue_lock);
|
|
|
|
dev->cmd_event = STU300_EVENT_NONE;
|
|
|
|
dev->cmd_err = STU300_ERROR_NONE;
|
|
|
|
|
|
|
|
adap = &dev->adapter;
|
|
|
|
adap->owner = THIS_MODULE;
|
|
|
|
/* DDC class but actually often used for more generic I2C */
|
2014-07-10 13:46:34 +02:00
|
|
|
adap->class = I2C_CLASS_DEPRECATED;
|
2011-01-31 15:09:23 +01:00
|
|
|
strlcpy(adap->name, "ST Microelectronics DDC I2C adapter",
|
2009-06-13 21:51:34 +02:00
|
|
|
sizeof(adap->name));
|
|
|
|
adap->nr = bus_nr;
|
|
|
|
adap->algo = &stu300_algo;
|
|
|
|
adap->dev.parent = &pdev->dev;
|
2013-04-11 14:59:47 +02:00
|
|
|
adap->dev.of_node = pdev->dev.of_node;
|
2009-06-13 21:51:34 +02:00
|
|
|
i2c_set_adapdata(adap, dev);
|
|
|
|
|
|
|
|
/* i2c device drivers may be active on return from add_adapter() */
|
|
|
|
ret = i2c_add_numbered_adapter(adap);
|
2016-08-09 13:36:17 +02:00
|
|
|
if (ret)
|
2012-07-16 13:30:12 +02:00
|
|
|
return ret;
|
2009-06-13 21:51:34 +02:00
|
|
|
|
2012-07-16 13:30:12 +02:00
|
|
|
platform_set_drvdata(pdev, dev);
|
2013-04-11 14:59:47 +02:00
|
|
|
dev_info(&pdev->dev, "ST DDC I2C @ %p, irq %d\n",
|
|
|
|
dev->virtbase, dev->irq);
|
|
|
|
|
2012-07-16 13:30:12 +02:00
|
|
|
return 0;
|
2009-06-13 21:51:34 +02:00
|
|
|
}
|
|
|
|
|
2013-07-15 04:29:56 +02:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2012-07-11 21:26:36 +02:00
|
|
|
static int stu300_suspend(struct device *device)
|
2009-06-13 21:51:34 +02:00
|
|
|
{
|
2012-07-11 21:26:36 +02:00
|
|
|
struct stu300_dev *dev = dev_get_drvdata(device);
|
2009-06-13 21:51:34 +02:00
|
|
|
|
|
|
|
/* Turn off everything */
|
|
|
|
stu300_wr8(0x00, dev->virtbase + I2C_CR);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-07-11 21:26:36 +02:00
|
|
|
static int stu300_resume(struct device *device)
|
2009-06-13 21:51:34 +02:00
|
|
|
{
|
|
|
|
int ret = 0;
|
2012-07-11 21:26:36 +02:00
|
|
|
struct stu300_dev *dev = dev_get_drvdata(device);
|
2009-06-13 21:51:34 +02:00
|
|
|
|
|
|
|
clk_enable(dev->clk);
|
|
|
|
ret = stu300_init_hw(dev);
|
|
|
|
clk_disable(dev->clk);
|
|
|
|
|
|
|
|
if (ret != 0)
|
2012-07-11 21:26:36 +02:00
|
|
|
dev_err(device, "error re-initializing hardware.\n");
|
2009-06-13 21:51:34 +02:00
|
|
|
return ret;
|
|
|
|
}
|
2012-07-11 21:26:36 +02:00
|
|
|
|
|
|
|
static SIMPLE_DEV_PM_OPS(stu300_pm, stu300_suspend, stu300_resume);
|
|
|
|
#define STU300_I2C_PM (&stu300_pm)
|
2009-06-13 21:51:34 +02:00
|
|
|
#else
|
2012-07-11 21:26:36 +02:00
|
|
|
#define STU300_I2C_PM NULL
|
2009-06-13 21:51:34 +02:00
|
|
|
#endif
|
|
|
|
|
2013-10-08 22:35:36 +02:00
|
|
|
static int stu300_remove(struct platform_device *pdev)
|
2009-06-13 21:51:34 +02:00
|
|
|
{
|
|
|
|
struct stu300_dev *dev = platform_get_drvdata(pdev);
|
|
|
|
|
|
|
|
i2c_del_adapter(&dev->adapter);
|
|
|
|
/* Turn off everything */
|
|
|
|
stu300_wr8(0x00, dev->virtbase + I2C_CR);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-04-11 14:59:47 +02:00
|
|
|
static const struct of_device_id stu300_dt_match[] = {
|
|
|
|
{ .compatible = "st,ddci2c" },
|
|
|
|
{},
|
|
|
|
};
|
2015-10-20 16:16:30 +02:00
|
|
|
MODULE_DEVICE_TABLE(of, stu300_dt_match);
|
2013-04-11 14:59:47 +02:00
|
|
|
|
2009-06-13 21:51:34 +02:00
|
|
|
static struct platform_driver stu300_i2c_driver = {
|
|
|
|
.driver = {
|
|
|
|
.name = NAME,
|
2012-07-11 21:26:36 +02:00
|
|
|
.pm = STU300_I2C_PM,
|
2013-04-11 14:59:47 +02:00
|
|
|
.of_match_table = stu300_dt_match,
|
2009-06-13 21:51:34 +02:00
|
|
|
},
|
2013-10-08 22:35:36 +02:00
|
|
|
.probe = stu300_probe,
|
|
|
|
.remove = stu300_remove,
|
2009-06-13 21:51:34 +02:00
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init stu300_init(void)
|
|
|
|
{
|
2013-10-08 22:35:36 +02:00
|
|
|
return platform_driver_register(&stu300_i2c_driver);
|
2009-06-13 21:51:34 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit stu300_exit(void)
|
|
|
|
{
|
|
|
|
platform_driver_unregister(&stu300_i2c_driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The systems using this bus often have very basic devices such
|
|
|
|
* as regulators on the I2C bus, so this needs to be loaded early.
|
|
|
|
* Therefore it is registered in the subsys_initcall().
|
|
|
|
*/
|
|
|
|
subsys_initcall(stu300_init);
|
|
|
|
module_exit(stu300_exit);
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Linus Walleij <linus.walleij@stericsson.com>");
|
|
|
|
MODULE_DESCRIPTION("ST Micro DDC I2C adapter (" NAME ")");
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_ALIAS("platform:" NAME);
|