2006-08-13 15:44:09 -06:00
|
|
|
/*
|
|
|
|
* TI OMAP I2C master mode driver
|
|
|
|
*
|
|
|
|
* Copyright (C) 2003 MontaVista Software, Inc.
|
|
|
|
* Copyright (C) 2005 Nokia Corporation
|
2008-11-21 14:39:47 -07:00
|
|
|
* Copyright (C) 2004 - 2007 Texas Instruments.
|
2006-08-13 15:44:09 -06:00
|
|
|
*
|
2008-11-21 14:39:47 -07:00
|
|
|
* Originally written by MontaVista Software, Inc.
|
|
|
|
* Additional contributions by:
|
|
|
|
* Tony Lindgren <tony@atomide.com>
|
|
|
|
* Imre Deak <imre.deak@nokia.com>
|
|
|
|
* Juha Yrjölä <juha.yrjola@solidboot.com>
|
|
|
|
* Syed Khasim <x0khasim@ti.com>
|
|
|
|
* Nishant Menon <nm@ti.com>
|
2006-08-13 15:44:09 -06:00
|
|
|
*
|
|
|
|
* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/i2c.h>
|
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/completion.h>
|
|
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/clk.h>
|
2008-11-21 14:39:47 -07:00
|
|
|
#include <linux/io.h>
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2008-11-21 14:39:55 -07:00
|
|
|
/* I2C controller revisions */
|
|
|
|
#define OMAP_I2C_REV_2 0x20
|
|
|
|
|
|
|
|
/* I2C controller revisions present on specific hardware */
|
|
|
|
#define OMAP_I2C_REV_ON_2430 0x36
|
|
|
|
#define OMAP_I2C_REV_ON_3430 0x3C
|
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
/* timeout waiting for the controller to respond */
|
|
|
|
#define OMAP_I2C_TIMEOUT (msecs_to_jiffies(1000))
|
|
|
|
|
|
|
|
#define OMAP_I2C_REV_REG 0x00
|
|
|
|
#define OMAP_I2C_IE_REG 0x04
|
|
|
|
#define OMAP_I2C_STAT_REG 0x08
|
|
|
|
#define OMAP_I2C_IV_REG 0x0c
|
2008-11-21 14:39:55 -07:00
|
|
|
/* For OMAP3 I2C_IV has changed to I2C_WE (wakeup enable) */
|
|
|
|
#define OMAP_I2C_WE_REG 0x0c
|
2006-08-13 15:44:09 -06:00
|
|
|
#define OMAP_I2C_SYSS_REG 0x10
|
|
|
|
#define OMAP_I2C_BUF_REG 0x14
|
|
|
|
#define OMAP_I2C_CNT_REG 0x18
|
|
|
|
#define OMAP_I2C_DATA_REG 0x1c
|
|
|
|
#define OMAP_I2C_SYSC_REG 0x20
|
|
|
|
#define OMAP_I2C_CON_REG 0x24
|
|
|
|
#define OMAP_I2C_OA_REG 0x28
|
|
|
|
#define OMAP_I2C_SA_REG 0x2c
|
|
|
|
#define OMAP_I2C_PSC_REG 0x30
|
|
|
|
#define OMAP_I2C_SCLL_REG 0x34
|
|
|
|
#define OMAP_I2C_SCLH_REG 0x38
|
|
|
|
#define OMAP_I2C_SYSTEST_REG 0x3c
|
2008-11-21 14:39:46 -07:00
|
|
|
#define OMAP_I2C_BUFSTAT_REG 0x40
|
2006-08-13 15:44:09 -06:00
|
|
|
|
|
|
|
/* I2C Interrupt Enable Register (OMAP_I2C_IE): */
|
2008-11-21 14:39:46 -07:00
|
|
|
#define OMAP_I2C_IE_XDR (1 << 14) /* TX Buffer drain int enable */
|
|
|
|
#define OMAP_I2C_IE_RDR (1 << 13) /* RX Buffer drain int enable */
|
2006-08-13 15:44:09 -06:00
|
|
|
#define OMAP_I2C_IE_XRDY (1 << 4) /* TX data ready int enable */
|
|
|
|
#define OMAP_I2C_IE_RRDY (1 << 3) /* RX data ready int enable */
|
|
|
|
#define OMAP_I2C_IE_ARDY (1 << 2) /* Access ready int enable */
|
|
|
|
#define OMAP_I2C_IE_NACK (1 << 1) /* No ack interrupt enable */
|
|
|
|
#define OMAP_I2C_IE_AL (1 << 0) /* Arbitration lost int ena */
|
|
|
|
|
|
|
|
/* I2C Status Register (OMAP_I2C_STAT): */
|
2008-11-21 14:39:46 -07:00
|
|
|
#define OMAP_I2C_STAT_XDR (1 << 14) /* TX Buffer draining */
|
|
|
|
#define OMAP_I2C_STAT_RDR (1 << 13) /* RX Buffer draining */
|
2006-08-13 15:44:09 -06:00
|
|
|
#define OMAP_I2C_STAT_BB (1 << 12) /* Bus busy */
|
|
|
|
#define OMAP_I2C_STAT_ROVR (1 << 11) /* Receive overrun */
|
|
|
|
#define OMAP_I2C_STAT_XUDF (1 << 10) /* Transmit underflow */
|
|
|
|
#define OMAP_I2C_STAT_AAS (1 << 9) /* Address as slave */
|
|
|
|
#define OMAP_I2C_STAT_AD0 (1 << 8) /* Address zero */
|
|
|
|
#define OMAP_I2C_STAT_XRDY (1 << 4) /* Transmit data ready */
|
|
|
|
#define OMAP_I2C_STAT_RRDY (1 << 3) /* Receive data ready */
|
|
|
|
#define OMAP_I2C_STAT_ARDY (1 << 2) /* Register access ready */
|
|
|
|
#define OMAP_I2C_STAT_NACK (1 << 1) /* No ack interrupt enable */
|
|
|
|
#define OMAP_I2C_STAT_AL (1 << 0) /* Arbitration lost int ena */
|
|
|
|
|
2008-11-21 14:39:55 -07:00
|
|
|
/* I2C WE wakeup enable register */
|
|
|
|
#define OMAP_I2C_WE_XDR_WE (1 << 14) /* TX drain wakup */
|
|
|
|
#define OMAP_I2C_WE_RDR_WE (1 << 13) /* RX drain wakeup */
|
|
|
|
#define OMAP_I2C_WE_AAS_WE (1 << 9) /* Address as slave wakeup*/
|
|
|
|
#define OMAP_I2C_WE_BF_WE (1 << 8) /* Bus free wakeup */
|
|
|
|
#define OMAP_I2C_WE_STC_WE (1 << 6) /* Start condition wakeup */
|
|
|
|
#define OMAP_I2C_WE_GC_WE (1 << 5) /* General call wakeup */
|
|
|
|
#define OMAP_I2C_WE_DRDY_WE (1 << 3) /* TX/RX data ready wakeup */
|
|
|
|
#define OMAP_I2C_WE_ARDY_WE (1 << 2) /* Reg access ready wakeup */
|
|
|
|
#define OMAP_I2C_WE_NACK_WE (1 << 1) /* No acknowledgment wakeup */
|
|
|
|
#define OMAP_I2C_WE_AL_WE (1 << 0) /* Arbitration lost wakeup */
|
|
|
|
|
|
|
|
#define OMAP_I2C_WE_ALL (OMAP_I2C_WE_XDR_WE | OMAP_I2C_WE_RDR_WE | \
|
|
|
|
OMAP_I2C_WE_AAS_WE | OMAP_I2C_WE_BF_WE | \
|
|
|
|
OMAP_I2C_WE_STC_WE | OMAP_I2C_WE_GC_WE | \
|
|
|
|
OMAP_I2C_WE_DRDY_WE | OMAP_I2C_WE_ARDY_WE | \
|
|
|
|
OMAP_I2C_WE_NACK_WE | OMAP_I2C_WE_AL_WE)
|
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
/* I2C Buffer Configuration Register (OMAP_I2C_BUF): */
|
|
|
|
#define OMAP_I2C_BUF_RDMA_EN (1 << 15) /* RX DMA channel enable */
|
2008-11-21 14:39:46 -07:00
|
|
|
#define OMAP_I2C_BUF_RXFIF_CLR (1 << 14) /* RX FIFO Clear */
|
2006-08-13 15:44:09 -06:00
|
|
|
#define OMAP_I2C_BUF_XDMA_EN (1 << 7) /* TX DMA channel enable */
|
2008-11-21 14:39:46 -07:00
|
|
|
#define OMAP_I2C_BUF_TXFIF_CLR (1 << 6) /* TX FIFO Clear */
|
2006-08-13 15:44:09 -06:00
|
|
|
|
|
|
|
/* I2C Configuration Register (OMAP_I2C_CON): */
|
|
|
|
#define OMAP_I2C_CON_EN (1 << 15) /* I2C module enable */
|
|
|
|
#define OMAP_I2C_CON_BE (1 << 14) /* Big endian mode */
|
2008-11-21 14:39:46 -07:00
|
|
|
#define OMAP_I2C_CON_OPMODE_HS (1 << 12) /* High Speed support */
|
2006-08-13 15:44:09 -06:00
|
|
|
#define OMAP_I2C_CON_STB (1 << 11) /* Start byte mode (master) */
|
|
|
|
#define OMAP_I2C_CON_MST (1 << 10) /* Master/slave mode */
|
|
|
|
#define OMAP_I2C_CON_TRX (1 << 9) /* TX/RX mode (master only) */
|
|
|
|
#define OMAP_I2C_CON_XA (1 << 8) /* Expand address */
|
|
|
|
#define OMAP_I2C_CON_RM (1 << 2) /* Repeat mode (master only) */
|
|
|
|
#define OMAP_I2C_CON_STP (1 << 1) /* Stop cond (master only) */
|
|
|
|
#define OMAP_I2C_CON_STT (1 << 0) /* Start condition (master) */
|
|
|
|
|
2008-11-21 14:39:45 -07:00
|
|
|
/* I2C SCL time value when Master */
|
|
|
|
#define OMAP_I2C_SCLL_HSSCLL 8
|
|
|
|
#define OMAP_I2C_SCLH_HSSCLH 8
|
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
/* I2C System Test Register (OMAP_I2C_SYSTEST): */
|
|
|
|
#ifdef DEBUG
|
|
|
|
#define OMAP_I2C_SYSTEST_ST_EN (1 << 15) /* System test enable */
|
|
|
|
#define OMAP_I2C_SYSTEST_FREE (1 << 14) /* Free running mode */
|
|
|
|
#define OMAP_I2C_SYSTEST_TMODE_MASK (3 << 12) /* Test mode select */
|
|
|
|
#define OMAP_I2C_SYSTEST_TMODE_SHIFT (12) /* Test mode select */
|
|
|
|
#define OMAP_I2C_SYSTEST_SCL_I (1 << 3) /* SCL line sense in */
|
|
|
|
#define OMAP_I2C_SYSTEST_SCL_O (1 << 2) /* SCL line drive out */
|
|
|
|
#define OMAP_I2C_SYSTEST_SDA_I (1 << 1) /* SDA line sense in */
|
|
|
|
#define OMAP_I2C_SYSTEST_SDA_O (1 << 0) /* SDA line drive out */
|
|
|
|
#endif
|
|
|
|
|
2008-11-21 14:39:55 -07:00
|
|
|
/* OCP_SYSSTATUS bit definitions */
|
|
|
|
#define SYSS_RESETDONE_MASK (1 << 0)
|
|
|
|
|
|
|
|
/* OCP_SYSCONFIG bit definitions */
|
|
|
|
#define SYSC_CLOCKACTIVITY_MASK (0x3 << 8)
|
|
|
|
#define SYSC_SIDLEMODE_MASK (0x3 << 3)
|
|
|
|
#define SYSC_ENAWAKEUP_MASK (1 << 2)
|
|
|
|
#define SYSC_SOFTRESET_MASK (1 << 1)
|
|
|
|
#define SYSC_AUTOIDLE_MASK (1 << 0)
|
|
|
|
|
|
|
|
#define SYSC_IDLEMODE_SMART 0x2
|
|
|
|
#define SYSC_CLOCKACTIVITY_FCLK 0x2
|
2006-08-13 15:44:09 -06:00
|
|
|
|
|
|
|
|
|
|
|
struct omap_i2c_dev {
|
|
|
|
struct device *dev;
|
|
|
|
void __iomem *base; /* virtual */
|
|
|
|
int irq;
|
|
|
|
struct clk *iclk; /* Interface clock */
|
|
|
|
struct clk *fclk; /* Functional clock */
|
|
|
|
struct completion cmd_complete;
|
|
|
|
struct resource *ioarea;
|
2008-11-21 14:39:45 -07:00
|
|
|
u32 speed; /* Speed of bus in Khz */
|
2006-08-13 15:44:09 -06:00
|
|
|
u16 cmd_err;
|
|
|
|
u8 *buf;
|
|
|
|
size_t buf_len;
|
|
|
|
struct i2c_adapter adapter;
|
2008-11-21 14:39:46 -07:00
|
|
|
u8 fifo_size; /* use as flag and value
|
|
|
|
* fifo_size==0 implies no fifo
|
|
|
|
* if set, should be trsh+1
|
|
|
|
*/
|
2008-11-21 14:39:55 -07:00
|
|
|
u8 rev;
|
2008-11-21 14:39:46 -07:00
|
|
|
unsigned b_hw:1; /* bad h/w fixes */
|
2008-03-23 13:28:20 -06:00
|
|
|
unsigned idle:1;
|
|
|
|
u16 iestate; /* Saved interrupt register */
|
2006-08-13 15:44:09 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static inline void omap_i2c_write_reg(struct omap_i2c_dev *i2c_dev,
|
|
|
|
int reg, u16 val)
|
|
|
|
{
|
|
|
|
__raw_writew(val, i2c_dev->base + reg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u16 omap_i2c_read_reg(struct omap_i2c_dev *i2c_dev, int reg)
|
|
|
|
{
|
|
|
|
return __raw_readw(i2c_dev->base + reg);
|
|
|
|
}
|
|
|
|
|
2008-11-21 14:39:46 -07:00
|
|
|
static int __init omap_i2c_get_clocks(struct omap_i2c_dev *dev)
|
2006-08-13 15:44:09 -06:00
|
|
|
{
|
2009-01-23 15:57:12 -07:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
dev->iclk = clk_get(dev->dev, "ick");
|
|
|
|
if (IS_ERR(dev->iclk)) {
|
|
|
|
ret = PTR_ERR(dev->iclk);
|
|
|
|
dev->iclk = NULL;
|
|
|
|
return ret;
|
2006-08-13 15:44:09 -06:00
|
|
|
}
|
|
|
|
|
2009-01-19 14:02:29 -07:00
|
|
|
dev->fclk = clk_get(dev->dev, "fck");
|
2006-08-13 15:44:09 -06:00
|
|
|
if (IS_ERR(dev->fclk)) {
|
2009-01-23 15:57:12 -07:00
|
|
|
ret = PTR_ERR(dev->fclk);
|
2006-08-13 15:44:09 -06:00
|
|
|
if (dev->iclk != NULL) {
|
|
|
|
clk_put(dev->iclk);
|
|
|
|
dev->iclk = NULL;
|
|
|
|
}
|
|
|
|
dev->fclk = NULL;
|
2009-01-23 15:57:12 -07:00
|
|
|
return ret;
|
2006-08-13 15:44:09 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void omap_i2c_put_clocks(struct omap_i2c_dev *dev)
|
|
|
|
{
|
|
|
|
clk_put(dev->fclk);
|
|
|
|
dev->fclk = NULL;
|
2009-01-23 15:57:12 -07:00
|
|
|
clk_put(dev->iclk);
|
|
|
|
dev->iclk = NULL;
|
2006-08-13 15:44:09 -06:00
|
|
|
}
|
|
|
|
|
2008-03-23 13:28:20 -06:00
|
|
|
static void omap_i2c_unidle(struct omap_i2c_dev *dev)
|
2006-08-13 15:44:09 -06:00
|
|
|
{
|
2008-11-21 14:39:47 -07:00
|
|
|
WARN_ON(!dev->idle);
|
|
|
|
|
2009-01-23 15:57:12 -07:00
|
|
|
clk_enable(dev->iclk);
|
2006-08-13 15:44:09 -06:00
|
|
|
clk_enable(dev->fclk);
|
i2c-omap: Close suspected race between omap_i2c_idle() and omap_i2c_isr()
omap_i2c_idle() sets an internal flag, "dev->idle", instructing its
ISR to decline interrupts. It sets this flag before it actually masks
the interrupts on the I2C controller. This is problematic, since an
I2C interrupt could arrive after dev->idle is set, but before the
interrupt source is masked. When this happens, Linux disables the I2C
controller's IRQ, causing all future transactions on the bus to fail.
Symptoms, happening on about 7% of boots:
irq 56: nobody cared (try booting with the "irqpoll" option)
<warning traceback here>
Disabling IRQ #56
i2c_omap i2c_omap.1: controller timed out
In omap_i2c_idle(), this patch sets dev->idle only after the interrupt
mask write to the I2C controller has left the ARM write buffer.
That's probably the major offender. For additional prophylaxis, in
omap_i2c_unidle(), the patch clears the dev->idle flag before
interrupts are enabled, rather than afterwards.
The patch has survived twenty-two reboots on the 3430SDP here without
wedging I2C1. Not absolutely dispositive, but promising!
Signed-off-by: Paul Walmsley <paul@pwsan.com>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2008-11-21 14:39:45 -07:00
|
|
|
dev->idle = 0;
|
2008-03-23 13:28:20 -06:00
|
|
|
if (dev->iestate)
|
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_IE_REG, dev->iestate);
|
2006-08-13 15:44:09 -06:00
|
|
|
}
|
|
|
|
|
2008-03-23 13:28:20 -06:00
|
|
|
static void omap_i2c_idle(struct omap_i2c_dev *dev)
|
2006-08-13 15:44:09 -06:00
|
|
|
{
|
2008-03-23 13:28:20 -06:00
|
|
|
u16 iv;
|
|
|
|
|
2008-11-21 14:39:47 -07:00
|
|
|
WARN_ON(dev->idle);
|
|
|
|
|
2008-03-23 13:28:20 -06:00
|
|
|
dev->iestate = omap_i2c_read_reg(dev, OMAP_I2C_IE_REG);
|
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_IE_REG, 0);
|
2008-11-21 14:39:55 -07:00
|
|
|
if (dev->rev < OMAP_I2C_REV_2) {
|
2008-11-21 14:39:47 -07:00
|
|
|
iv = omap_i2c_read_reg(dev, OMAP_I2C_IV_REG); /* Read clears */
|
i2c-omap: Close suspected race between omap_i2c_idle() and omap_i2c_isr()
omap_i2c_idle() sets an internal flag, "dev->idle", instructing its
ISR to decline interrupts. It sets this flag before it actually masks
the interrupts on the I2C controller. This is problematic, since an
I2C interrupt could arrive after dev->idle is set, but before the
interrupt source is masked. When this happens, Linux disables the I2C
controller's IRQ, causing all future transactions on the bus to fail.
Symptoms, happening on about 7% of boots:
irq 56: nobody cared (try booting with the "irqpoll" option)
<warning traceback here>
Disabling IRQ #56
i2c_omap i2c_omap.1: controller timed out
In omap_i2c_idle(), this patch sets dev->idle only after the interrupt
mask write to the I2C controller has left the ARM write buffer.
That's probably the major offender. For additional prophylaxis, in
omap_i2c_unidle(), the patch clears the dev->idle flag before
interrupts are enabled, rather than afterwards.
The patch has survived twenty-two reboots on the 3430SDP here without
wedging I2C1. Not absolutely dispositive, but promising!
Signed-off-by: Paul Walmsley <paul@pwsan.com>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2008-11-21 14:39:45 -07:00
|
|
|
} else {
|
2008-03-23 13:28:20 -06:00
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_STAT_REG, dev->iestate);
|
i2c-omap: Close suspected race between omap_i2c_idle() and omap_i2c_isr()
omap_i2c_idle() sets an internal flag, "dev->idle", instructing its
ISR to decline interrupts. It sets this flag before it actually masks
the interrupts on the I2C controller. This is problematic, since an
I2C interrupt could arrive after dev->idle is set, but before the
interrupt source is masked. When this happens, Linux disables the I2C
controller's IRQ, causing all future transactions on the bus to fail.
Symptoms, happening on about 7% of boots:
irq 56: nobody cared (try booting with the "irqpoll" option)
<warning traceback here>
Disabling IRQ #56
i2c_omap i2c_omap.1: controller timed out
In omap_i2c_idle(), this patch sets dev->idle only after the interrupt
mask write to the I2C controller has left the ARM write buffer.
That's probably the major offender. For additional prophylaxis, in
omap_i2c_unidle(), the patch clears the dev->idle flag before
interrupts are enabled, rather than afterwards.
The patch has survived twenty-two reboots on the 3430SDP here without
wedging I2C1. Not absolutely dispositive, but promising!
Signed-off-by: Paul Walmsley <paul@pwsan.com>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2008-11-21 14:39:45 -07:00
|
|
|
|
|
|
|
/* Flush posted write before the dev->idle store occurs */
|
|
|
|
omap_i2c_read_reg(dev, OMAP_I2C_STAT_REG);
|
|
|
|
}
|
|
|
|
dev->idle = 1;
|
2008-03-23 13:28:20 -06:00
|
|
|
clk_disable(dev->fclk);
|
2009-01-23 15:57:12 -07:00
|
|
|
clk_disable(dev->iclk);
|
2006-08-13 15:44:09 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int omap_i2c_init(struct omap_i2c_dev *dev)
|
|
|
|
{
|
2008-11-21 14:39:45 -07:00
|
|
|
u16 psc = 0, scll = 0, sclh = 0;
|
|
|
|
u16 fsscll = 0, fssclh = 0, hsscll = 0, hssclh = 0;
|
2006-08-13 15:44:09 -06:00
|
|
|
unsigned long fclk_rate = 12000000;
|
|
|
|
unsigned long timeout;
|
2008-11-21 14:39:45 -07:00
|
|
|
unsigned long internal_clk = 0;
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2008-11-21 14:39:55 -07:00
|
|
|
if (dev->rev >= OMAP_I2C_REV_2) {
|
2008-11-21 14:39:55 -07:00
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_SYSC_REG, SYSC_SOFTRESET_MASK);
|
2006-08-13 15:44:09 -06:00
|
|
|
/* For some reason we need to set the EN bit before the
|
|
|
|
* reset done bit gets set. */
|
|
|
|
timeout = jiffies + OMAP_I2C_TIMEOUT;
|
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_CON_REG, OMAP_I2C_CON_EN);
|
|
|
|
while (!(omap_i2c_read_reg(dev, OMAP_I2C_SYSS_REG) &
|
2008-11-21 14:39:55 -07:00
|
|
|
SYSS_RESETDONE_MASK)) {
|
2006-08-13 15:44:09 -06:00
|
|
|
if (time_after(jiffies, timeout)) {
|
2007-12-12 05:45:24 -07:00
|
|
|
dev_warn(dev->dev, "timeout waiting "
|
2006-08-13 15:44:09 -06:00
|
|
|
"for controller reset\n");
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
}
|
|
|
|
msleep(1);
|
|
|
|
}
|
2008-11-21 14:39:55 -07:00
|
|
|
|
|
|
|
/* SYSC register is cleared by the reset; rewrite it */
|
|
|
|
if (dev->rev == OMAP_I2C_REV_ON_2430) {
|
|
|
|
|
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_SYSC_REG,
|
|
|
|
SYSC_AUTOIDLE_MASK);
|
|
|
|
|
|
|
|
} else if (dev->rev >= OMAP_I2C_REV_ON_3430) {
|
|
|
|
u32 v;
|
|
|
|
|
|
|
|
v = SYSC_AUTOIDLE_MASK;
|
|
|
|
v |= SYSC_ENAWAKEUP_MASK;
|
|
|
|
v |= (SYSC_IDLEMODE_SMART <<
|
|
|
|
__ffs(SYSC_SIDLEMODE_MASK));
|
|
|
|
v |= (SYSC_CLOCKACTIVITY_FCLK <<
|
|
|
|
__ffs(SYSC_CLOCKACTIVITY_MASK));
|
|
|
|
|
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_SYSC_REG, v);
|
2008-11-21 14:39:55 -07:00
|
|
|
/*
|
|
|
|
* Enabling all wakup sources to stop I2C freezing on
|
|
|
|
* WFI instruction.
|
|
|
|
* REVISIT: Some wkup sources might not be needed.
|
|
|
|
*/
|
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_WE_REG,
|
|
|
|
OMAP_I2C_WE_ALL);
|
2008-11-21 14:39:55 -07:00
|
|
|
|
|
|
|
}
|
2006-08-13 15:44:09 -06:00
|
|
|
}
|
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_CON_REG, 0);
|
|
|
|
|
|
|
|
if (cpu_class_is_omap1()) {
|
2009-01-22 12:31:46 -07:00
|
|
|
/*
|
|
|
|
* The I2C functional clock is the armxor_ck, so there's
|
|
|
|
* no need to get "armxor_ck" separately. Now, if OMAP2420
|
|
|
|
* always returns 12MHz for the functional clock, we can
|
|
|
|
* do this bit unconditionally.
|
|
|
|
*/
|
|
|
|
fclk_rate = clk_get_rate(dev->fclk);
|
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
/* TRM for 5912 says the I2C clock must be prescaled to be
|
|
|
|
* between 7 - 12 MHz. The XOR input clock is typically
|
|
|
|
* 12, 13 or 19.2 MHz. So we should have code that produces:
|
|
|
|
*
|
|
|
|
* XOR MHz Divider Prescaler
|
|
|
|
* 12 1 0
|
|
|
|
* 13 2 1
|
|
|
|
* 19.2 2 1
|
|
|
|
*/
|
2006-12-10 13:21:34 -07:00
|
|
|
if (fclk_rate > 12000000)
|
|
|
|
psc = fclk_rate / 12000000;
|
2006-08-13 15:44:09 -06:00
|
|
|
}
|
|
|
|
|
2008-11-21 14:39:46 -07:00
|
|
|
if (cpu_is_omap2430() || cpu_is_omap34xx()) {
|
2008-11-21 14:39:45 -07:00
|
|
|
|
2009-05-27 08:54:46 -06:00
|
|
|
/*
|
|
|
|
* HSI2C controller internal clk rate should be 19.2 Mhz for
|
|
|
|
* HS and for all modes on 2430. On 34xx we can use lower rate
|
|
|
|
* to get longer filter period for better noise suppression.
|
|
|
|
* The filter is iclk (fclk for HS) period.
|
|
|
|
*/
|
2009-06-17 04:20:21 -06:00
|
|
|
if (dev->speed > 400 || cpu_is_omap2430())
|
2009-05-27 08:54:46 -06:00
|
|
|
internal_clk = 19200;
|
|
|
|
else if (dev->speed > 100)
|
|
|
|
internal_clk = 9600;
|
|
|
|
else
|
|
|
|
internal_clk = 4000;
|
2008-11-21 14:39:45 -07:00
|
|
|
fclk_rate = clk_get_rate(dev->fclk) / 1000;
|
|
|
|
|
|
|
|
/* Compute prescaler divisor */
|
|
|
|
psc = fclk_rate / internal_clk;
|
|
|
|
psc = psc - 1;
|
|
|
|
|
|
|
|
/* If configured for High Speed */
|
|
|
|
if (dev->speed > 400) {
|
2009-05-27 08:54:45 -06:00
|
|
|
unsigned long scl;
|
|
|
|
|
2008-11-21 14:39:45 -07:00
|
|
|
/* For first phase of HS mode */
|
2009-05-27 08:54:45 -06:00
|
|
|
scl = internal_clk / 400;
|
|
|
|
fsscll = scl - (scl / 3) - 7;
|
|
|
|
fssclh = (scl / 3) - 5;
|
2008-11-21 14:39:45 -07:00
|
|
|
|
|
|
|
/* For second phase of HS mode */
|
2009-05-27 08:54:45 -06:00
|
|
|
scl = fclk_rate / dev->speed;
|
|
|
|
hsscll = scl - (scl / 3) - 7;
|
|
|
|
hssclh = (scl / 3) - 5;
|
|
|
|
} else if (dev->speed > 100) {
|
|
|
|
unsigned long scl;
|
|
|
|
|
|
|
|
/* Fast mode */
|
|
|
|
scl = internal_clk / dev->speed;
|
|
|
|
fsscll = scl - (scl / 3) - 7;
|
|
|
|
fssclh = (scl / 3) - 5;
|
2008-11-21 14:39:45 -07:00
|
|
|
} else {
|
2009-05-27 08:54:45 -06:00
|
|
|
/* Standard mode */
|
|
|
|
fsscll = internal_clk / (dev->speed * 2) - 7;
|
|
|
|
fssclh = internal_clk / (dev->speed * 2) - 5;
|
2008-11-21 14:39:45 -07:00
|
|
|
}
|
|
|
|
scll = (hsscll << OMAP_I2C_SCLL_HSSCLL) | fsscll;
|
|
|
|
sclh = (hssclh << OMAP_I2C_SCLH_HSSCLH) | fssclh;
|
|
|
|
} else {
|
|
|
|
/* Program desired operating rate */
|
|
|
|
fclk_rate /= (psc + 1) * 1000;
|
|
|
|
if (psc > 2)
|
|
|
|
psc = 2;
|
|
|
|
scll = fclk_rate / (dev->speed * 2) - 7 + psc;
|
|
|
|
sclh = fclk_rate / (dev->speed * 2) - 7 + psc;
|
|
|
|
}
|
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
/* Setup clock prescaler to obtain approx 12MHz I2C module clock: */
|
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_PSC_REG, psc);
|
|
|
|
|
2008-11-21 14:39:45 -07:00
|
|
|
/* SCL low and high time values */
|
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_SCLL_REG, scll);
|
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_SCLH_REG, sclh);
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2008-11-21 14:39:46 -07:00
|
|
|
if (dev->fifo_size)
|
|
|
|
/* Note: setup required fifo size - 1 */
|
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_BUF_REG,
|
|
|
|
(dev->fifo_size - 1) << 8 | /* RTRSH */
|
|
|
|
OMAP_I2C_BUF_RXFIF_CLR |
|
|
|
|
(dev->fifo_size - 1) | /* XTRSH */
|
|
|
|
OMAP_I2C_BUF_TXFIF_CLR);
|
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
/* Take the I2C module out of reset: */
|
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_CON_REG, OMAP_I2C_CON_EN);
|
|
|
|
|
|
|
|
/* Enable interrupts */
|
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_IE_REG,
|
2008-11-21 14:39:47 -07:00
|
|
|
(OMAP_I2C_IE_XRDY | OMAP_I2C_IE_RRDY |
|
|
|
|
OMAP_I2C_IE_ARDY | OMAP_I2C_IE_NACK |
|
|
|
|
OMAP_I2C_IE_AL) | ((dev->fifo_size) ?
|
2008-11-21 14:39:46 -07:00
|
|
|
(OMAP_I2C_IE_RDR | OMAP_I2C_IE_XDR) : 0));
|
2006-08-13 15:44:09 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Waiting on Bus Busy
|
|
|
|
*/
|
|
|
|
static int omap_i2c_wait_for_bb(struct omap_i2c_dev *dev)
|
|
|
|
{
|
|
|
|
unsigned long timeout;
|
|
|
|
|
|
|
|
timeout = jiffies + OMAP_I2C_TIMEOUT;
|
|
|
|
while (omap_i2c_read_reg(dev, OMAP_I2C_STAT_REG) & OMAP_I2C_STAT_BB) {
|
|
|
|
if (time_after(jiffies, timeout)) {
|
|
|
|
dev_warn(dev->dev, "timeout waiting for bus ready\n");
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
}
|
|
|
|
msleep(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Low level master read/write transaction.
|
|
|
|
*/
|
|
|
|
static int omap_i2c_xfer_msg(struct i2c_adapter *adap,
|
|
|
|
struct i2c_msg *msg, int stop)
|
|
|
|
{
|
|
|
|
struct omap_i2c_dev *dev = i2c_get_adapdata(adap);
|
|
|
|
int r;
|
|
|
|
u16 w;
|
|
|
|
|
|
|
|
dev_dbg(dev->dev, "addr: 0x%04x, len: %d, flags: 0x%x, stop: %d\n",
|
|
|
|
msg->addr, msg->len, msg->flags, stop);
|
|
|
|
|
|
|
|
if (msg->len == 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_SA_REG, msg->addr);
|
|
|
|
|
|
|
|
/* REVISIT: Could the STB bit of I2C_CON be used with probing? */
|
|
|
|
dev->buf = msg->buf;
|
|
|
|
dev->buf_len = msg->len;
|
|
|
|
|
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_CNT_REG, dev->buf_len);
|
|
|
|
|
2008-11-21 14:39:46 -07:00
|
|
|
/* Clear the FIFO Buffers */
|
|
|
|
w = omap_i2c_read_reg(dev, OMAP_I2C_BUF_REG);
|
|
|
|
w |= OMAP_I2C_BUF_RXFIF_CLR | OMAP_I2C_BUF_TXFIF_CLR;
|
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_BUF_REG, w);
|
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
init_completion(&dev->cmd_complete);
|
|
|
|
dev->cmd_err = 0;
|
|
|
|
|
|
|
|
w = OMAP_I2C_CON_EN | OMAP_I2C_CON_MST | OMAP_I2C_CON_STT;
|
2008-11-21 14:39:45 -07:00
|
|
|
|
|
|
|
/* High speed configuration */
|
|
|
|
if (dev->speed > 400)
|
2008-11-21 14:39:46 -07:00
|
|
|
w |= OMAP_I2C_CON_OPMODE_HS;
|
2008-11-21 14:39:45 -07:00
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
if (msg->flags & I2C_M_TEN)
|
|
|
|
w |= OMAP_I2C_CON_XA;
|
|
|
|
if (!(msg->flags & I2C_M_RD))
|
|
|
|
w |= OMAP_I2C_CON_TRX;
|
2008-11-21 14:39:47 -07:00
|
|
|
|
2008-11-21 14:39:46 -07:00
|
|
|
if (!dev->b_hw && stop)
|
2006-08-13 15:44:09 -06:00
|
|
|
w |= OMAP_I2C_CON_STP;
|
2008-11-21 14:39:47 -07:00
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_CON_REG, w);
|
|
|
|
|
2008-11-21 14:39:46 -07:00
|
|
|
/*
|
|
|
|
* Don't write stt and stp together on some hardware.
|
|
|
|
*/
|
|
|
|
if (dev->b_hw && stop) {
|
|
|
|
unsigned long delay = jiffies + OMAP_I2C_TIMEOUT;
|
|
|
|
u16 con = omap_i2c_read_reg(dev, OMAP_I2C_CON_REG);
|
|
|
|
while (con & OMAP_I2C_CON_STT) {
|
|
|
|
con = omap_i2c_read_reg(dev, OMAP_I2C_CON_REG);
|
|
|
|
|
|
|
|
/* Let the user know if i2c is in a bad state */
|
|
|
|
if (time_after(jiffies, delay)) {
|
|
|
|
dev_err(dev->dev, "controller timed out "
|
|
|
|
"waiting for start condition to finish\n");
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
}
|
|
|
|
cpu_relax();
|
|
|
|
}
|
|
|
|
|
|
|
|
w |= OMAP_I2C_CON_STP;
|
|
|
|
w &= ~OMAP_I2C_CON_STT;
|
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_CON_REG, w);
|
|
|
|
}
|
|
|
|
|
2008-11-21 14:39:45 -07:00
|
|
|
/*
|
|
|
|
* REVISIT: We should abort the transfer on signals, but the bus goes
|
|
|
|
* into arbitration and we're currently unable to recover from it.
|
|
|
|
*/
|
|
|
|
r = wait_for_completion_timeout(&dev->cmd_complete,
|
|
|
|
OMAP_I2C_TIMEOUT);
|
2006-08-13 15:44:09 -06:00
|
|
|
dev->buf_len = 0;
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
if (r == 0) {
|
|
|
|
dev_err(dev->dev, "controller timed out\n");
|
|
|
|
omap_i2c_init(dev);
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (likely(!dev->cmd_err))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* We have an error */
|
|
|
|
if (dev->cmd_err & (OMAP_I2C_STAT_AL | OMAP_I2C_STAT_ROVR |
|
|
|
|
OMAP_I2C_STAT_XUDF)) {
|
|
|
|
omap_i2c_init(dev);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dev->cmd_err & OMAP_I2C_STAT_NACK) {
|
|
|
|
if (msg->flags & I2C_M_IGNORE_NAK)
|
|
|
|
return 0;
|
|
|
|
if (stop) {
|
|
|
|
w = omap_i2c_read_reg(dev, OMAP_I2C_CON_REG);
|
|
|
|
w |= OMAP_I2C_CON_STP;
|
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_CON_REG, w);
|
|
|
|
}
|
|
|
|
return -EREMOTEIO;
|
|
|
|
}
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Prepare controller for a transaction and call omap_i2c_xfer_msg
|
|
|
|
* to do the work during IRQ processing.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
omap_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num)
|
|
|
|
{
|
|
|
|
struct omap_i2c_dev *dev = i2c_get_adapdata(adap);
|
|
|
|
int i;
|
|
|
|
int r;
|
|
|
|
|
2008-03-23 13:28:20 -06:00
|
|
|
omap_i2c_unidle(dev);
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2008-11-21 14:39:47 -07:00
|
|
|
r = omap_i2c_wait_for_bb(dev);
|
|
|
|
if (r < 0)
|
2006-08-13 15:44:09 -06:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
for (i = 0; i < num; i++) {
|
|
|
|
r = omap_i2c_xfer_msg(adap, &msgs[i], (i == (num - 1)));
|
|
|
|
if (r != 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (r == 0)
|
|
|
|
r = num;
|
|
|
|
out:
|
2008-03-23 13:28:20 -06:00
|
|
|
omap_i2c_idle(dev);
|
2006-08-13 15:44:09 -06:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32
|
|
|
|
omap_i2c_func(struct i2c_adapter *adap)
|
|
|
|
{
|
|
|
|
return I2C_FUNC_I2C | (I2C_FUNC_SMBUS_EMUL & ~I2C_FUNC_SMBUS_QUICK);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
omap_i2c_complete_cmd(struct omap_i2c_dev *dev, u16 err)
|
|
|
|
{
|
|
|
|
dev->cmd_err |= err;
|
|
|
|
complete(&dev->cmd_complete);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
omap_i2c_ack_stat(struct omap_i2c_dev *dev, u16 stat)
|
|
|
|
{
|
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_STAT_REG, stat);
|
|
|
|
}
|
|
|
|
|
2008-11-21 14:39:47 -07:00
|
|
|
/* rev1 devices are apparently only on some 15xx */
|
|
|
|
#ifdef CONFIG_ARCH_OMAP15XX
|
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
static irqreturn_t
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 07:55:46 -06:00
|
|
|
omap_i2c_rev1_isr(int this_irq, void *dev_id)
|
2006-08-13 15:44:09 -06:00
|
|
|
{
|
|
|
|
struct omap_i2c_dev *dev = dev_id;
|
|
|
|
u16 iv, w;
|
|
|
|
|
2008-03-23 13:28:20 -06:00
|
|
|
if (dev->idle)
|
|
|
|
return IRQ_NONE;
|
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
iv = omap_i2c_read_reg(dev, OMAP_I2C_IV_REG);
|
|
|
|
switch (iv) {
|
|
|
|
case 0x00: /* None */
|
|
|
|
break;
|
|
|
|
case 0x01: /* Arbitration lost */
|
|
|
|
dev_err(dev->dev, "Arbitration lost\n");
|
|
|
|
omap_i2c_complete_cmd(dev, OMAP_I2C_STAT_AL);
|
|
|
|
break;
|
|
|
|
case 0x02: /* No acknowledgement */
|
|
|
|
omap_i2c_complete_cmd(dev, OMAP_I2C_STAT_NACK);
|
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_CON_REG, OMAP_I2C_CON_STP);
|
|
|
|
break;
|
|
|
|
case 0x03: /* Register access ready */
|
|
|
|
omap_i2c_complete_cmd(dev, 0);
|
|
|
|
break;
|
|
|
|
case 0x04: /* Receive data ready */
|
|
|
|
if (dev->buf_len) {
|
|
|
|
w = omap_i2c_read_reg(dev, OMAP_I2C_DATA_REG);
|
|
|
|
*dev->buf++ = w;
|
|
|
|
dev->buf_len--;
|
|
|
|
if (dev->buf_len) {
|
|
|
|
*dev->buf++ = w >> 8;
|
|
|
|
dev->buf_len--;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
dev_err(dev->dev, "RRDY IRQ while no data requested\n");
|
|
|
|
break;
|
|
|
|
case 0x05: /* Transmit data ready */
|
|
|
|
if (dev->buf_len) {
|
|
|
|
w = *dev->buf++;
|
|
|
|
dev->buf_len--;
|
|
|
|
if (dev->buf_len) {
|
|
|
|
w |= *dev->buf++ << 8;
|
|
|
|
dev->buf_len--;
|
|
|
|
}
|
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_DATA_REG, w);
|
|
|
|
} else
|
|
|
|
dev_err(dev->dev, "XRDY IRQ while no data to send\n");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return IRQ_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
2008-11-21 14:39:47 -07:00
|
|
|
#else
|
2008-11-21 14:39:47 -07:00
|
|
|
#define omap_i2c_rev1_isr NULL
|
2008-11-21 14:39:47 -07:00
|
|
|
#endif
|
2006-08-13 15:44:09 -06:00
|
|
|
|
|
|
|
static irqreturn_t
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 07:55:46 -06:00
|
|
|
omap_i2c_isr(int this_irq, void *dev_id)
|
2006-08-13 15:44:09 -06:00
|
|
|
{
|
|
|
|
struct omap_i2c_dev *dev = dev_id;
|
|
|
|
u16 bits;
|
|
|
|
u16 stat, w;
|
2008-11-21 14:39:46 -07:00
|
|
|
int err, count = 0;
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2008-03-23 13:28:20 -06:00
|
|
|
if (dev->idle)
|
|
|
|
return IRQ_NONE;
|
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
bits = omap_i2c_read_reg(dev, OMAP_I2C_IE_REG);
|
|
|
|
while ((stat = (omap_i2c_read_reg(dev, OMAP_I2C_STAT_REG))) & bits) {
|
|
|
|
dev_dbg(dev->dev, "IRQ (ISR = 0x%04x)\n", stat);
|
|
|
|
if (count++ == 100) {
|
|
|
|
dev_warn(dev->dev, "Too much work in one IRQ\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-07-21 09:15:12 -06:00
|
|
|
err = 0;
|
|
|
|
complete:
|
2009-08-20 10:21:14 -06:00
|
|
|
/*
|
|
|
|
* Ack the stat in one go, but [R/X]DR and [R/X]RDY should be
|
|
|
|
* acked after the data operation is complete.
|
|
|
|
* Ref: TRM SWPU114Q Figure 18-31
|
|
|
|
*/
|
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_STAT_REG, stat &
|
|
|
|
~(OMAP_I2C_STAT_RRDY | OMAP_I2C_STAT_RDR |
|
|
|
|
OMAP_I2C_STAT_XRDY | OMAP_I2C_STAT_XDR));
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2008-11-21 14:39:46 -07:00
|
|
|
if (stat & OMAP_I2C_STAT_NACK) {
|
|
|
|
err |= OMAP_I2C_STAT_NACK;
|
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_CON_REG,
|
|
|
|
OMAP_I2C_CON_STP);
|
2006-08-13 15:44:09 -06:00
|
|
|
}
|
2008-11-21 14:39:46 -07:00
|
|
|
if (stat & OMAP_I2C_STAT_AL) {
|
|
|
|
dev_err(dev->dev, "Arbitration lost\n");
|
|
|
|
err |= OMAP_I2C_STAT_AL;
|
|
|
|
}
|
|
|
|
if (stat & (OMAP_I2C_STAT_ARDY | OMAP_I2C_STAT_NACK |
|
2009-07-21 09:14:40 -06:00
|
|
|
OMAP_I2C_STAT_AL)) {
|
2009-08-20 10:21:15 -06:00
|
|
|
omap_i2c_ack_stat(dev, stat &
|
|
|
|
(OMAP_I2C_STAT_RRDY | OMAP_I2C_STAT_RDR |
|
|
|
|
OMAP_I2C_STAT_XRDY | OMAP_I2C_STAT_XDR));
|
2008-11-21 14:39:46 -07:00
|
|
|
omap_i2c_complete_cmd(dev, err);
|
2009-07-21 09:14:40 -06:00
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
2008-11-21 14:39:46 -07:00
|
|
|
if (stat & (OMAP_I2C_STAT_RRDY | OMAP_I2C_STAT_RDR)) {
|
|
|
|
u8 num_bytes = 1;
|
|
|
|
if (dev->fifo_size) {
|
|
|
|
if (stat & OMAP_I2C_STAT_RRDY)
|
|
|
|
num_bytes = dev->fifo_size;
|
2009-07-21 09:14:06 -06:00
|
|
|
else /* read RXSTAT on RDR interrupt */
|
|
|
|
num_bytes = (omap_i2c_read_reg(dev,
|
|
|
|
OMAP_I2C_BUFSTAT_REG)
|
|
|
|
>> 8) & 0x3F;
|
2008-11-21 14:39:46 -07:00
|
|
|
}
|
|
|
|
while (num_bytes) {
|
|
|
|
num_bytes--;
|
|
|
|
w = omap_i2c_read_reg(dev, OMAP_I2C_DATA_REG);
|
2006-08-13 15:44:09 -06:00
|
|
|
if (dev->buf_len) {
|
2008-11-21 14:39:46 -07:00
|
|
|
*dev->buf++ = w;
|
2006-08-13 15:44:09 -06:00
|
|
|
dev->buf_len--;
|
2008-11-21 14:39:46 -07:00
|
|
|
/* Data reg from 2430 is 8 bit wide */
|
2008-11-21 14:39:46 -07:00
|
|
|
if (!cpu_is_omap2430() &&
|
|
|
|
!cpu_is_omap34xx()) {
|
2008-11-21 14:39:46 -07:00
|
|
|
if (dev->buf_len) {
|
|
|
|
*dev->buf++ = w >> 8;
|
|
|
|
dev->buf_len--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (stat & OMAP_I2C_STAT_RRDY)
|
|
|
|
dev_err(dev->dev,
|
|
|
|
"RRDY IRQ while no data"
|
|
|
|
" requested\n");
|
|
|
|
if (stat & OMAP_I2C_STAT_RDR)
|
|
|
|
dev_err(dev->dev,
|
|
|
|
"RDR IRQ while no data"
|
|
|
|
" requested\n");
|
|
|
|
break;
|
2006-08-13 15:44:09 -06:00
|
|
|
}
|
2008-11-21 14:39:46 -07:00
|
|
|
}
|
|
|
|
omap_i2c_ack_stat(dev,
|
|
|
|
stat & (OMAP_I2C_STAT_RRDY | OMAP_I2C_STAT_RDR));
|
2006-08-13 15:44:09 -06:00
|
|
|
continue;
|
|
|
|
}
|
2008-11-21 14:39:46 -07:00
|
|
|
if (stat & (OMAP_I2C_STAT_XRDY | OMAP_I2C_STAT_XDR)) {
|
|
|
|
u8 num_bytes = 1;
|
|
|
|
if (dev->fifo_size) {
|
|
|
|
if (stat & OMAP_I2C_STAT_XRDY)
|
|
|
|
num_bytes = dev->fifo_size;
|
2009-07-21 09:14:06 -06:00
|
|
|
else /* read TXSTAT on XDR interrupt */
|
2008-11-21 14:39:46 -07:00
|
|
|
num_bytes = omap_i2c_read_reg(dev,
|
2009-07-21 09:14:06 -06:00
|
|
|
OMAP_I2C_BUFSTAT_REG)
|
|
|
|
& 0x3F;
|
2008-11-21 14:39:46 -07:00
|
|
|
}
|
|
|
|
while (num_bytes) {
|
|
|
|
num_bytes--;
|
|
|
|
w = 0;
|
2006-08-13 15:44:09 -06:00
|
|
|
if (dev->buf_len) {
|
2008-11-21 14:39:46 -07:00
|
|
|
w = *dev->buf++;
|
2006-08-13 15:44:09 -06:00
|
|
|
dev->buf_len--;
|
2008-11-21 14:39:46 -07:00
|
|
|
/* Data reg from 2430 is 8 bit wide */
|
2008-11-21 14:39:46 -07:00
|
|
|
if (!cpu_is_omap2430() &&
|
|
|
|
!cpu_is_omap34xx()) {
|
2008-11-21 14:39:46 -07:00
|
|
|
if (dev->buf_len) {
|
|
|
|
w |= *dev->buf++ << 8;
|
|
|
|
dev->buf_len--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (stat & OMAP_I2C_STAT_XRDY)
|
|
|
|
dev_err(dev->dev,
|
|
|
|
"XRDY IRQ while no "
|
|
|
|
"data to send\n");
|
|
|
|
if (stat & OMAP_I2C_STAT_XDR)
|
|
|
|
dev_err(dev->dev,
|
|
|
|
"XDR IRQ while no "
|
|
|
|
"data to send\n");
|
|
|
|
break;
|
2006-08-13 15:44:09 -06:00
|
|
|
}
|
2009-07-21 09:15:12 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* OMAP3430 Errata 1.153: When an XRDY/XDR
|
|
|
|
* is hit, wait for XUDF before writing data
|
|
|
|
* to DATA_REG. Otherwise some data bytes can
|
|
|
|
* be lost while transferring them from the
|
|
|
|
* memory to the I2C interface.
|
|
|
|
*/
|
|
|
|
|
2009-08-20 10:21:16 -06:00
|
|
|
if (dev->rev <= OMAP_I2C_REV_ON_3430) {
|
2009-07-21 09:15:12 -06:00
|
|
|
while (!(stat & OMAP_I2C_STAT_XUDF)) {
|
|
|
|
if (stat & (OMAP_I2C_STAT_NACK | OMAP_I2C_STAT_AL)) {
|
|
|
|
omap_i2c_ack_stat(dev, stat & (OMAP_I2C_STAT_XRDY | OMAP_I2C_STAT_XDR));
|
|
|
|
err |= OMAP_I2C_STAT_XUDF;
|
|
|
|
goto complete;
|
|
|
|
}
|
|
|
|
cpu_relax();
|
|
|
|
stat = omap_i2c_read_reg(dev, OMAP_I2C_STAT_REG);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-11-21 14:39:46 -07:00
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_DATA_REG, w);
|
|
|
|
}
|
|
|
|
omap_i2c_ack_stat(dev,
|
|
|
|
stat & (OMAP_I2C_STAT_XRDY | OMAP_I2C_STAT_XDR));
|
2006-08-13 15:44:09 -06:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (stat & OMAP_I2C_STAT_ROVR) {
|
|
|
|
dev_err(dev->dev, "Receive overrun\n");
|
|
|
|
dev->cmd_err |= OMAP_I2C_STAT_ROVR;
|
|
|
|
}
|
|
|
|
if (stat & OMAP_I2C_STAT_XUDF) {
|
2008-11-21 14:39:46 -07:00
|
|
|
dev_err(dev->dev, "Transmit underflow\n");
|
2006-08-13 15:44:09 -06:00
|
|
|
dev->cmd_err |= OMAP_I2C_STAT_XUDF;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return count ? IRQ_HANDLED : IRQ_NONE;
|
|
|
|
}
|
|
|
|
|
2006-09-03 14:39:46 -06:00
|
|
|
static const struct i2c_algorithm omap_i2c_algo = {
|
2006-08-13 15:44:09 -06:00
|
|
|
.master_xfer = omap_i2c_xfer,
|
|
|
|
.functionality = omap_i2c_func,
|
|
|
|
};
|
|
|
|
|
2008-11-21 14:39:46 -07:00
|
|
|
static int __init
|
2006-08-13 15:44:09 -06:00
|
|
|
omap_i2c_probe(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct omap_i2c_dev *dev;
|
|
|
|
struct i2c_adapter *adap;
|
|
|
|
struct resource *mem, *irq, *ioarea;
|
2008-12-16 15:08:08 -07:00
|
|
|
irq_handler_t isr;
|
2006-08-13 15:44:09 -06:00
|
|
|
int r;
|
2008-11-21 14:39:46 -07:00
|
|
|
u32 speed = 0;
|
2006-08-13 15:44:09 -06:00
|
|
|
|
|
|
|
/* NOTE: driver uses the static register mapping */
|
|
|
|
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
|
|
if (!mem) {
|
|
|
|
dev_err(&pdev->dev, "no mem resource?\n");
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
|
|
|
|
if (!irq) {
|
|
|
|
dev_err(&pdev->dev, "no irq resource?\n");
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2009-07-05 00:37:50 -06:00
|
|
|
ioarea = request_mem_region(mem->start, resource_size(mem),
|
2006-08-13 15:44:09 -06:00
|
|
|
pdev->name);
|
|
|
|
if (!ioarea) {
|
|
|
|
dev_err(&pdev->dev, "I2C region already claimed\n");
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev = kzalloc(sizeof(struct omap_i2c_dev), GFP_KERNEL);
|
|
|
|
if (!dev) {
|
|
|
|
r = -ENOMEM;
|
|
|
|
goto err_release_region;
|
|
|
|
}
|
|
|
|
|
2008-11-21 14:39:45 -07:00
|
|
|
if (pdev->dev.platform_data != NULL)
|
2008-11-21 14:39:46 -07:00
|
|
|
speed = *(u32 *)pdev->dev.platform_data;
|
2008-11-21 14:39:45 -07:00
|
|
|
else
|
2008-11-21 14:39:46 -07:00
|
|
|
speed = 100; /* Defualt speed */
|
2008-11-21 14:39:45 -07:00
|
|
|
|
2008-11-21 14:39:46 -07:00
|
|
|
dev->speed = speed;
|
2008-11-21 14:39:47 -07:00
|
|
|
dev->idle = 1;
|
2006-08-13 15:44:09 -06:00
|
|
|
dev->dev = &pdev->dev;
|
|
|
|
dev->irq = irq->start;
|
2009-06-13 16:20:36 -06:00
|
|
|
dev->base = ioremap(mem->start, resource_size(mem));
|
2008-09-04 07:07:22 -06:00
|
|
|
if (!dev->base) {
|
|
|
|
r = -ENOMEM;
|
|
|
|
goto err_free_mem;
|
|
|
|
}
|
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
platform_set_drvdata(pdev, dev);
|
|
|
|
|
|
|
|
if ((r = omap_i2c_get_clocks(dev)) != 0)
|
2008-09-04 07:07:22 -06:00
|
|
|
goto err_iounmap;
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2008-03-23 13:28:20 -06:00
|
|
|
omap_i2c_unidle(dev);
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2008-11-21 14:39:55 -07:00
|
|
|
dev->rev = omap_i2c_read_reg(dev, OMAP_I2C_REV_REG) & 0xff;
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2008-11-21 14:39:46 -07:00
|
|
|
if (cpu_is_omap2430() || cpu_is_omap34xx()) {
|
2008-11-21 14:39:46 -07:00
|
|
|
u16 s;
|
|
|
|
|
|
|
|
/* Set up the fifo size - Get total size */
|
|
|
|
s = (omap_i2c_read_reg(dev, OMAP_I2C_BUFSTAT_REG) >> 14) & 0x3;
|
|
|
|
dev->fifo_size = 0x8 << s;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set up notification threshold as half the total available
|
|
|
|
* size. This is to ensure that we can handle the status on int
|
|
|
|
* call back latencies.
|
|
|
|
*/
|
|
|
|
dev->fifo_size = (dev->fifo_size / 2);
|
|
|
|
dev->b_hw = 1; /* Enable hardware fixes */
|
|
|
|
}
|
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
/* reset ASAP, clearing any IRQs */
|
|
|
|
omap_i2c_init(dev);
|
|
|
|
|
2008-11-21 14:39:55 -07:00
|
|
|
isr = (dev->rev < OMAP_I2C_REV_2) ? omap_i2c_rev1_isr : omap_i2c_isr;
|
|
|
|
r = request_irq(dev->irq, isr, 0, pdev->name, dev);
|
2006-08-13 15:44:09 -06:00
|
|
|
|
|
|
|
if (r) {
|
|
|
|
dev_err(dev->dev, "failure requesting irq %i\n", dev->irq);
|
|
|
|
goto err_unuse_clocks;
|
|
|
|
}
|
2008-11-21 14:39:55 -07:00
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
dev_info(dev->dev, "bus %d rev%d.%d at %d kHz\n",
|
2008-11-21 14:39:55 -07:00
|
|
|
pdev->id, dev->rev >> 4, dev->rev & 0xf, dev->speed);
|
2006-08-13 15:44:09 -06:00
|
|
|
|
2008-11-21 14:39:47 -07:00
|
|
|
omap_i2c_idle(dev);
|
|
|
|
|
2006-08-13 15:44:09 -06:00
|
|
|
adap = &dev->adapter;
|
|
|
|
i2c_set_adapdata(adap, dev);
|
|
|
|
adap->owner = THIS_MODULE;
|
|
|
|
adap->class = I2C_CLASS_HWMON;
|
2009-07-17 07:24:00 -06:00
|
|
|
strlcpy(adap->name, "OMAP I2C adapter", sizeof(adap->name));
|
2006-08-13 15:44:09 -06:00
|
|
|
adap->algo = &omap_i2c_algo;
|
|
|
|
adap->dev.parent = &pdev->dev;
|
|
|
|
|
|
|
|
/* i2c device drivers may be active on return from add_adapter() */
|
2007-05-01 15:26:32 -06:00
|
|
|
adap->nr = pdev->id;
|
|
|
|
r = i2c_add_numbered_adapter(adap);
|
2006-08-13 15:44:09 -06:00
|
|
|
if (r) {
|
|
|
|
dev_err(dev->dev, "failure adding adapter\n");
|
|
|
|
goto err_free_irq;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_free_irq:
|
|
|
|
free_irq(dev->irq, dev);
|
|
|
|
err_unuse_clocks:
|
2008-01-14 13:53:30 -07:00
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_CON_REG, 0);
|
2008-03-23 13:28:20 -06:00
|
|
|
omap_i2c_idle(dev);
|
2006-08-13 15:44:09 -06:00
|
|
|
omap_i2c_put_clocks(dev);
|
2008-09-04 07:07:22 -06:00
|
|
|
err_iounmap:
|
|
|
|
iounmap(dev->base);
|
2006-08-13 15:44:09 -06:00
|
|
|
err_free_mem:
|
|
|
|
platform_set_drvdata(pdev, NULL);
|
|
|
|
kfree(dev);
|
|
|
|
err_release_region:
|
2009-07-05 00:37:50 -06:00
|
|
|
release_mem_region(mem->start, resource_size(mem));
|
2006-08-13 15:44:09 -06:00
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
omap_i2c_remove(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct omap_i2c_dev *dev = platform_get_drvdata(pdev);
|
|
|
|
struct resource *mem;
|
|
|
|
|
|
|
|
platform_set_drvdata(pdev, NULL);
|
|
|
|
|
|
|
|
free_irq(dev->irq, dev);
|
|
|
|
i2c_del_adapter(&dev->adapter);
|
|
|
|
omap_i2c_write_reg(dev, OMAP_I2C_CON_REG, 0);
|
|
|
|
omap_i2c_put_clocks(dev);
|
2008-09-04 07:07:22 -06:00
|
|
|
iounmap(dev->base);
|
2006-08-13 15:44:09 -06:00
|
|
|
kfree(dev);
|
|
|
|
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
2009-07-05 00:37:50 -06:00
|
|
|
release_mem_region(mem->start, resource_size(mem));
|
2006-08-13 15:44:09 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct platform_driver omap_i2c_driver = {
|
|
|
|
.probe = omap_i2c_probe,
|
|
|
|
.remove = omap_i2c_remove,
|
|
|
|
.driver = {
|
|
|
|
.name = "i2c_omap",
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
/* I2C may be needed to bring up other drivers */
|
|
|
|
static int __init
|
|
|
|
omap_i2c_init_driver(void)
|
|
|
|
{
|
|
|
|
return platform_driver_register(&omap_i2c_driver);
|
|
|
|
}
|
|
|
|
subsys_initcall(omap_i2c_init_driver);
|
|
|
|
|
|
|
|
static void __exit omap_i2c_exit_driver(void)
|
|
|
|
{
|
|
|
|
platform_driver_unregister(&omap_i2c_driver);
|
|
|
|
}
|
|
|
|
module_exit(omap_i2c_exit_driver);
|
|
|
|
|
|
|
|
MODULE_AUTHOR("MontaVista Software, Inc. (and others)");
|
|
|
|
MODULE_DESCRIPTION("TI OMAP I2C bus adapter");
|
|
|
|
MODULE_LICENSE("GPL");
|
2008-04-22 14:16:49 -06:00
|
|
|
MODULE_ALIAS("platform:i2c_omap");
|