a90f933507
Detection class I2C_CLASS_TV_DIGITAL is set by many adapters but no I2C device driver is setting it anymore, which means it can be dropped. I2C devices on digital TV adapters are instantiated explicitly these days, which is much better. Signed-off-by: Jean Delvare <khali@linux-fr.org> Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
267 lines
6.6 KiB
C
267 lines
6.6 KiB
C
/*
|
|
Mantis PCI bridge driver
|
|
|
|
Copyright (C) Manu Abraham (abraham.manu@gmail.com)
|
|
|
|
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 <asm/io.h>
|
|
#include <linux/ioport.h>
|
|
#include <linux/pci.h>
|
|
#include <linux/i2c.h>
|
|
|
|
#include "dmxdev.h"
|
|
#include "dvbdev.h"
|
|
#include "dvb_demux.h"
|
|
#include "dvb_frontend.h"
|
|
#include "dvb_net.h"
|
|
|
|
#include "mantis_common.h"
|
|
#include "mantis_reg.h"
|
|
#include "mantis_i2c.h"
|
|
|
|
#define TRIALS 10000
|
|
|
|
static int mantis_i2c_read(struct mantis_pci *mantis, const struct i2c_msg *msg)
|
|
{
|
|
u32 rxd, i, stat, trials;
|
|
|
|
dprintk(MANTIS_INFO, 0, " %s: Address=[0x%02x] <R>[ ",
|
|
__func__, msg->addr);
|
|
|
|
for (i = 0; i < msg->len; i++) {
|
|
rxd = (msg->addr << 25) | (1 << 24)
|
|
| MANTIS_I2C_RATE_3
|
|
| MANTIS_I2C_STOP
|
|
| MANTIS_I2C_PGMODE;
|
|
|
|
if (i == (msg->len - 1))
|
|
rxd &= ~MANTIS_I2C_STOP;
|
|
|
|
mmwrite(MANTIS_INT_I2CDONE, MANTIS_INT_STAT);
|
|
mmwrite(rxd, MANTIS_I2CDATA_CTL);
|
|
|
|
/* wait for xfer completion */
|
|
for (trials = 0; trials < TRIALS; trials++) {
|
|
stat = mmread(MANTIS_INT_STAT);
|
|
if (stat & MANTIS_INT_I2CDONE)
|
|
break;
|
|
}
|
|
|
|
dprintk(MANTIS_TMG, 0, "I2CDONE: trials=%d\n", trials);
|
|
|
|
/* wait for xfer completion */
|
|
for (trials = 0; trials < TRIALS; trials++) {
|
|
stat = mmread(MANTIS_INT_STAT);
|
|
if (stat & MANTIS_INT_I2CRACK)
|
|
break;
|
|
}
|
|
|
|
dprintk(MANTIS_TMG, 0, "I2CRACK: trials=%d\n", trials);
|
|
|
|
rxd = mmread(MANTIS_I2CDATA_CTL);
|
|
msg->buf[i] = (u8)((rxd >> 8) & 0xFF);
|
|
dprintk(MANTIS_INFO, 0, "%02x ", msg->buf[i]);
|
|
}
|
|
dprintk(MANTIS_INFO, 0, "]\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int mantis_i2c_write(struct mantis_pci *mantis, const struct i2c_msg *msg)
|
|
{
|
|
int i;
|
|
u32 txd = 0, stat, trials;
|
|
|
|
dprintk(MANTIS_INFO, 0, " %s: Address=[0x%02x] <W>[ ",
|
|
__func__, msg->addr);
|
|
|
|
for (i = 0; i < msg->len; i++) {
|
|
dprintk(MANTIS_INFO, 0, "%02x ", msg->buf[i]);
|
|
txd = (msg->addr << 25) | (msg->buf[i] << 8)
|
|
| MANTIS_I2C_RATE_3
|
|
| MANTIS_I2C_STOP
|
|
| MANTIS_I2C_PGMODE;
|
|
|
|
if (i == (msg->len - 1))
|
|
txd &= ~MANTIS_I2C_STOP;
|
|
|
|
mmwrite(MANTIS_INT_I2CDONE, MANTIS_INT_STAT);
|
|
mmwrite(txd, MANTIS_I2CDATA_CTL);
|
|
|
|
/* wait for xfer completion */
|
|
for (trials = 0; trials < TRIALS; trials++) {
|
|
stat = mmread(MANTIS_INT_STAT);
|
|
if (stat & MANTIS_INT_I2CDONE)
|
|
break;
|
|
}
|
|
|
|
dprintk(MANTIS_TMG, 0, "I2CDONE: trials=%d\n", trials);
|
|
|
|
/* wait for xfer completion */
|
|
for (trials = 0; trials < TRIALS; trials++) {
|
|
stat = mmread(MANTIS_INT_STAT);
|
|
if (stat & MANTIS_INT_I2CRACK)
|
|
break;
|
|
}
|
|
|
|
dprintk(MANTIS_TMG, 0, "I2CRACK: trials=%d\n", trials);
|
|
}
|
|
dprintk(MANTIS_INFO, 0, "]\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int mantis_i2c_xfer(struct i2c_adapter *adapter, struct i2c_msg *msgs, int num)
|
|
{
|
|
int ret = 0, i = 0, trials;
|
|
u32 stat, data, txd;
|
|
struct mantis_pci *mantis;
|
|
struct mantis_hwconfig *config;
|
|
|
|
mantis = i2c_get_adapdata(adapter);
|
|
BUG_ON(!mantis);
|
|
config = mantis->hwconfig;
|
|
BUG_ON(!config);
|
|
|
|
dprintk(MANTIS_DEBUG, 1, "Messages:%d", num);
|
|
mutex_lock(&mantis->i2c_lock);
|
|
|
|
while (i < num) {
|
|
/* Byte MODE */
|
|
if ((config->i2c_mode & MANTIS_BYTE_MODE) &&
|
|
((i + 1) < num) &&
|
|
(msgs[i].len < 2) &&
|
|
(msgs[i + 1].len < 2) &&
|
|
(msgs[i + 1].flags & I2C_M_RD)) {
|
|
|
|
dprintk(MANTIS_DEBUG, 0, " Byte MODE:\n");
|
|
|
|
/* Read operation */
|
|
txd = msgs[i].addr << 25 | (0x1 << 24)
|
|
| (msgs[i].buf[0] << 16)
|
|
| MANTIS_I2C_RATE_3;
|
|
|
|
mmwrite(txd, MANTIS_I2CDATA_CTL);
|
|
/* wait for xfer completion */
|
|
for (trials = 0; trials < TRIALS; trials++) {
|
|
stat = mmread(MANTIS_INT_STAT);
|
|
if (stat & MANTIS_INT_I2CDONE)
|
|
break;
|
|
}
|
|
|
|
/* check for xfer completion */
|
|
if (stat & MANTIS_INT_I2CDONE) {
|
|
/* check xfer was acknowledged */
|
|
if (stat & MANTIS_INT_I2CRACK) {
|
|
data = mmread(MANTIS_I2CDATA_CTL);
|
|
msgs[i + 1].buf[0] = (data >> 8) & 0xff;
|
|
dprintk(MANTIS_DEBUG, 0, " Byte <%d> RXD=0x%02x [%02x]\n", 0x0, data, msgs[i + 1].buf[0]);
|
|
} else {
|
|
/* I/O error */
|
|
dprintk(MANTIS_ERROR, 1, " I/O error, LINE:%d", __LINE__);
|
|
ret = -EIO;
|
|
break;
|
|
}
|
|
} else {
|
|
/* I/O error */
|
|
dprintk(MANTIS_ERROR, 1, " I/O error, LINE:%d", __LINE__);
|
|
ret = -EIO;
|
|
break;
|
|
}
|
|
i += 2; /* Write/Read operation in one go */
|
|
}
|
|
|
|
if (i < num) {
|
|
if (msgs[i].flags & I2C_M_RD)
|
|
ret = mantis_i2c_read(mantis, &msgs[i]);
|
|
else
|
|
ret = mantis_i2c_write(mantis, &msgs[i]);
|
|
|
|
i++;
|
|
if (ret < 0)
|
|
goto bail_out;
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&mantis->i2c_lock);
|
|
|
|
return num;
|
|
|
|
bail_out:
|
|
mutex_unlock(&mantis->i2c_lock);
|
|
return ret;
|
|
}
|
|
|
|
static u32 mantis_i2c_func(struct i2c_adapter *adapter)
|
|
{
|
|
return I2C_FUNC_SMBUS_EMUL;
|
|
}
|
|
|
|
static struct i2c_algorithm mantis_algo = {
|
|
.master_xfer = mantis_i2c_xfer,
|
|
.functionality = mantis_i2c_func,
|
|
};
|
|
|
|
int __devinit mantis_i2c_init(struct mantis_pci *mantis)
|
|
{
|
|
u32 intstat, intmask;
|
|
struct i2c_adapter *i2c_adapter = &mantis->adapter;
|
|
struct pci_dev *pdev = mantis->pdev;
|
|
|
|
init_waitqueue_head(&mantis->i2c_wq);
|
|
mutex_init(&mantis->i2c_lock);
|
|
strncpy(i2c_adapter->name, "Mantis I2C", sizeof(i2c_adapter->name));
|
|
i2c_set_adapdata(i2c_adapter, mantis);
|
|
|
|
i2c_adapter->owner = THIS_MODULE;
|
|
i2c_adapter->algo = &mantis_algo;
|
|
i2c_adapter->algo_data = NULL;
|
|
i2c_adapter->timeout = 500;
|
|
i2c_adapter->retries = 3;
|
|
i2c_adapter->dev.parent = &pdev->dev;
|
|
|
|
mantis->i2c_rc = i2c_add_adapter(i2c_adapter);
|
|
if (mantis->i2c_rc < 0)
|
|
return mantis->i2c_rc;
|
|
|
|
dprintk(MANTIS_DEBUG, 1, "Initializing I2C ..");
|
|
|
|
intstat = mmread(MANTIS_INT_STAT);
|
|
intmask = mmread(MANTIS_INT_MASK);
|
|
mmwrite(intstat, MANTIS_INT_STAT);
|
|
dprintk(MANTIS_DEBUG, 1, "Disabling I2C interrupt");
|
|
intmask = mmread(MANTIS_INT_MASK);
|
|
mmwrite((intmask & ~MANTIS_INT_I2CDONE), MANTIS_INT_MASK);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(mantis_i2c_init);
|
|
|
|
int mantis_i2c_exit(struct mantis_pci *mantis)
|
|
{
|
|
u32 intmask;
|
|
|
|
dprintk(MANTIS_DEBUG, 1, "Disabling I2C interrupt");
|
|
intmask = mmread(MANTIS_INT_MASK);
|
|
mmwrite((intmask & ~MANTIS_INT_I2CDONE), MANTIS_INT_MASK);
|
|
|
|
dprintk(MANTIS_DEBUG, 1, "Removing I2C adapter");
|
|
return i2c_del_adapter(&mantis->adapter);
|
|
}
|
|
EXPORT_SYMBOL_GPL(mantis_i2c_exit);
|