2006-01-18 14:41:50 -07:00
|
|
|
/*
|
2005-04-16 16:20:36 -06:00
|
|
|
Copyright (c) 2001,2002 Christer Weinigel <wingel@nano-system.com>
|
|
|
|
|
|
|
|
National Semiconductor SCx200 ACCESS.bus support
|
2006-01-18 14:48:26 -07:00
|
|
|
Also supports the AMD CS5535 and AMD CS5536
|
2006-01-18 14:41:50 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
Based on i2c-keywest.c which is:
|
|
|
|
Copyright (c) 2001 Benjamin Herrenschmidt <benh@kernel.crashing.org>
|
|
|
|
Copyright (c) 2000 Philip Edelbrock <phil@stimpy.netroedge.com>
|
2006-01-18 14:41:50 -07:00
|
|
|
|
2005-04-16 16:20:36 -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.
|
2006-01-18 14:41:50 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
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.
|
|
|
|
*/
|
|
|
|
|
2012-10-05 14:23:52 -06:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/i2c.h>
|
|
|
|
#include <linux/pci.h>
|
2010-12-30 21:27:33 -07:00
|
|
|
#include <linux/platform_device.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/delay.h>
|
2006-01-18 15:17:01 -07:00
|
|
|
#include <linux/mutex.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 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2010-05-21 10:41:01 -06:00
|
|
|
#include <linux/io.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#include <linux/scx200.h>
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Christer Weinigel <wingel@nano-system.com>");
|
|
|
|
MODULE_DESCRIPTION("NatSemi SCx200 ACCESS.bus Driver");
|
2010-12-30 21:27:33 -07:00
|
|
|
MODULE_ALIAS("platform:cs5535-smb");
|
2005-04-16 16:20:36 -06:00
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
|
|
|
#define MAX_DEVICES 4
|
|
|
|
static int base[MAX_DEVICES] = { 0x820, 0x840 };
|
2017-04-04 09:54:23 -06:00
|
|
|
module_param_hw_array(base, int, ioport, NULL, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
MODULE_PARM_DESC(base, "Base addresses for the ACCESS.bus controllers");
|
|
|
|
|
2006-01-18 14:52:06 -07:00
|
|
|
#define POLL_TIMEOUT (HZ/5)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
enum scx200_acb_state {
|
|
|
|
state_idle,
|
|
|
|
state_address,
|
|
|
|
state_command,
|
|
|
|
state_repeat_start,
|
|
|
|
state_quick,
|
|
|
|
state_read,
|
|
|
|
state_write,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const char *scx200_acb_state_name[] = {
|
|
|
|
"idle",
|
|
|
|
"address",
|
|
|
|
"command",
|
|
|
|
"repeat_start",
|
|
|
|
"quick",
|
|
|
|
"read",
|
|
|
|
"write",
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Physical interface */
|
2006-01-18 14:41:50 -07:00
|
|
|
struct scx200_acb_iface {
|
2005-04-16 16:20:36 -06:00
|
|
|
struct scx200_acb_iface *next;
|
|
|
|
struct i2c_adapter adapter;
|
|
|
|
unsigned base;
|
2006-01-18 15:17:01 -07:00
|
|
|
struct mutex mutex;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* State machine data */
|
|
|
|
enum scx200_acb_state state;
|
|
|
|
int result;
|
|
|
|
u8 address_byte;
|
|
|
|
u8 command;
|
|
|
|
u8 *ptr;
|
|
|
|
char needs_reset;
|
|
|
|
unsigned len;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Register Definitions */
|
|
|
|
#define ACBSDA (iface->base + 0)
|
|
|
|
#define ACBST (iface->base + 1)
|
|
|
|
#define ACBST_SDAST 0x40 /* SDA Status */
|
2006-01-18 14:41:50 -07:00
|
|
|
#define ACBST_BER 0x20
|
2005-04-16 16:20:36 -06:00
|
|
|
#define ACBST_NEGACK 0x10 /* Negative Acknowledge */
|
|
|
|
#define ACBST_STASTR 0x08 /* Stall After Start */
|
|
|
|
#define ACBST_MASTER 0x02
|
|
|
|
#define ACBCST (iface->base + 2)
|
|
|
|
#define ACBCST_BB 0x02
|
|
|
|
#define ACBCTL1 (iface->base + 3)
|
|
|
|
#define ACBCTL1_STASTRE 0x80
|
|
|
|
#define ACBCTL1_NMINTE 0x40
|
2006-01-18 14:41:50 -07:00
|
|
|
#define ACBCTL1_ACK 0x10
|
|
|
|
#define ACBCTL1_STOP 0x02
|
|
|
|
#define ACBCTL1_START 0x01
|
2005-04-16 16:20:36 -06:00
|
|
|
#define ACBADDR (iface->base + 4)
|
|
|
|
#define ACBCTL2 (iface->base + 5)
|
|
|
|
#define ACBCTL2_ENABLE 0x01
|
|
|
|
|
|
|
|
/************************************************************************/
|
|
|
|
|
|
|
|
static void scx200_acb_machine(struct scx200_acb_iface *iface, u8 status)
|
|
|
|
{
|
|
|
|
const char *errmsg;
|
|
|
|
|
2006-01-18 14:43:10 -07:00
|
|
|
dev_dbg(&iface->adapter.dev, "state %s, status = 0x%02x\n",
|
|
|
|
scx200_acb_state_name[iface->state], status);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (status & ACBST_BER) {
|
|
|
|
errmsg = "bus error";
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (!(status & ACBST_MASTER)) {
|
|
|
|
errmsg = "not master";
|
|
|
|
goto error;
|
|
|
|
}
|
2006-01-18 14:44:04 -07:00
|
|
|
if (status & ACBST_NEGACK) {
|
|
|
|
dev_dbg(&iface->adapter.dev, "negative ack in state %s\n",
|
|
|
|
scx200_acb_state_name[iface->state]);
|
|
|
|
|
|
|
|
iface->state = state_idle;
|
|
|
|
iface->result = -ENXIO;
|
|
|
|
|
|
|
|
outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1);
|
|
|
|
outb(ACBST_STASTR | ACBST_NEGACK, ACBST);
|
2006-04-28 14:53:30 -06:00
|
|
|
|
|
|
|
/* Reset the status register */
|
|
|
|
outb(0, ACBST);
|
2006-01-18 14:44:04 -07:00
|
|
|
return;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
switch (iface->state) {
|
|
|
|
case state_idle:
|
|
|
|
dev_warn(&iface->adapter.dev, "interrupt in idle state\n");
|
|
|
|
break;
|
|
|
|
|
|
|
|
case state_address:
|
|
|
|
/* Do a pointer write first */
|
|
|
|
outb(iface->address_byte & ~1, ACBSDA);
|
|
|
|
|
|
|
|
iface->state = state_command;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case state_command:
|
|
|
|
outb(iface->command, ACBSDA);
|
|
|
|
|
|
|
|
if (iface->address_byte & 1)
|
|
|
|
iface->state = state_repeat_start;
|
|
|
|
else
|
|
|
|
iface->state = state_write;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case state_repeat_start:
|
|
|
|
outb(inb(ACBCTL1) | ACBCTL1_START, ACBCTL1);
|
|
|
|
/* fallthrough */
|
2006-01-18 14:41:50 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
case state_quick:
|
|
|
|
if (iface->address_byte & 1) {
|
2006-01-18 14:41:50 -07:00
|
|
|
if (iface->len == 1)
|
2005-04-16 16:20:36 -06:00
|
|
|
outb(inb(ACBCTL1) | ACBCTL1_ACK, ACBCTL1);
|
|
|
|
else
|
|
|
|
outb(inb(ACBCTL1) & ~ACBCTL1_ACK, ACBCTL1);
|
|
|
|
outb(iface->address_byte, ACBSDA);
|
|
|
|
|
|
|
|
iface->state = state_read;
|
|
|
|
} else {
|
|
|
|
outb(iface->address_byte, ACBSDA);
|
|
|
|
|
|
|
|
iface->state = state_write;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case state_read:
|
2006-07-01 09:05:12 -06:00
|
|
|
/* Set ACK if _next_ byte will be the last one */
|
|
|
|
if (iface->len == 2)
|
2005-04-16 16:20:36 -06:00
|
|
|
outb(inb(ACBCTL1) | ACBCTL1_ACK, ACBCTL1);
|
|
|
|
else
|
|
|
|
outb(inb(ACBCTL1) & ~ACBCTL1_ACK, ACBCTL1);
|
|
|
|
|
2006-07-01 09:05:12 -06:00
|
|
|
if (iface->len == 1) {
|
2005-04-16 16:20:36 -06:00
|
|
|
iface->result = 0;
|
|
|
|
iface->state = state_idle;
|
|
|
|
outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1);
|
|
|
|
}
|
|
|
|
|
2006-07-01 09:05:12 -06:00
|
|
|
*iface->ptr++ = inb(ACBSDA);
|
|
|
|
--iface->len;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
case state_write:
|
|
|
|
if (iface->len == 0) {
|
|
|
|
iface->result = 0;
|
|
|
|
iface->state = state_idle;
|
|
|
|
outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1);
|
|
|
|
break;
|
|
|
|
}
|
2006-01-18 14:41:50 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
outb(*iface->ptr++, ACBSDA);
|
|
|
|
--iface->len;
|
2006-01-18 14:41:50 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
error:
|
2009-09-18 14:45:47 -06:00
|
|
|
dev_err(&iface->adapter.dev,
|
|
|
|
"%s in state %s (addr=0x%02x, len=%d, status=0x%02x)\n", errmsg,
|
|
|
|
scx200_acb_state_name[iface->state], iface->address_byte,
|
|
|
|
iface->len, status);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
iface->state = state_idle;
|
|
|
|
iface->result = -EIO;
|
|
|
|
iface->needs_reset = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void scx200_acb_poll(struct scx200_acb_iface *iface)
|
|
|
|
{
|
2006-01-18 14:44:04 -07:00
|
|
|
u8 status;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long timeout;
|
|
|
|
|
|
|
|
timeout = jiffies + POLL_TIMEOUT;
|
2006-08-05 13:15:19 -06:00
|
|
|
while (1) {
|
2005-04-16 16:20:36 -06:00
|
|
|
status = inb(ACBST);
|
2006-04-28 14:53:30 -06:00
|
|
|
|
|
|
|
/* Reset the status register to avoid the hang */
|
|
|
|
outb(0, ACBST);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if ((status & (ACBST_SDAST|ACBST_BER|ACBST_NEGACK)) != 0) {
|
|
|
|
scx200_acb_machine(iface, status);
|
|
|
|
return;
|
|
|
|
}
|
2006-08-05 13:15:19 -06:00
|
|
|
if (time_after(jiffies, timeout))
|
|
|
|
break;
|
|
|
|
cpu_relax();
|
|
|
|
cond_resched();
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-01-18 14:44:04 -07:00
|
|
|
dev_err(&iface->adapter.dev, "timeout in state %s\n",
|
|
|
|
scx200_acb_state_name[iface->state]);
|
|
|
|
|
|
|
|
iface->state = state_idle;
|
|
|
|
iface->result = -EIO;
|
|
|
|
iface->needs_reset = 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void scx200_acb_reset(struct scx200_acb_iface *iface)
|
|
|
|
{
|
|
|
|
/* Disable the ACCESS.bus device and Configure the SCL
|
2006-01-18 14:41:50 -07:00
|
|
|
frequency: 16 clock cycles */
|
2005-04-16 16:20:36 -06:00
|
|
|
outb(0x70, ACBCTL2);
|
|
|
|
/* Polling mode */
|
|
|
|
outb(0, ACBCTL1);
|
|
|
|
/* Disable slave address */
|
|
|
|
outb(0, ACBADDR);
|
|
|
|
/* Enable the ACCESS.bus device */
|
|
|
|
outb(inb(ACBCTL2) | ACBCTL2_ENABLE, ACBCTL2);
|
|
|
|
/* Free STALL after START */
|
|
|
|
outb(inb(ACBCTL1) & ~(ACBCTL1_STASTRE | ACBCTL1_NMINTE), ACBCTL1);
|
|
|
|
/* Send a STOP */
|
|
|
|
outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1);
|
|
|
|
/* Clear BER, NEGACK and STASTR bits */
|
|
|
|
outb(ACBST_BER | ACBST_NEGACK | ACBST_STASTR, ACBST);
|
|
|
|
/* Clear BB bit */
|
|
|
|
outb(inb(ACBCST) | ACBCST_BB, ACBCST);
|
|
|
|
}
|
|
|
|
|
|
|
|
static s32 scx200_acb_smbus_xfer(struct i2c_adapter *adapter,
|
2006-01-18 14:41:50 -07:00
|
|
|
u16 address, unsigned short flags,
|
|
|
|
char rw, u8 command, int size,
|
|
|
|
union i2c_smbus_data *data)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct scx200_acb_iface *iface = i2c_get_adapdata(adapter);
|
|
|
|
int len;
|
|
|
|
u8 *buffer;
|
|
|
|
u16 cur_word;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
switch (size) {
|
|
|
|
case I2C_SMBUS_QUICK:
|
2006-01-18 14:41:50 -07:00
|
|
|
len = 0;
|
|
|
|
buffer = NULL;
|
|
|
|
break;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
case I2C_SMBUS_BYTE:
|
2006-01-18 14:44:04 -07:00
|
|
|
len = 1;
|
|
|
|
buffer = rw ? &data->byte : &command;
|
2006-01-18 14:41:50 -07:00
|
|
|
break;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
case I2C_SMBUS_BYTE_DATA:
|
2006-01-18 14:41:50 -07:00
|
|
|
len = 1;
|
|
|
|
buffer = &data->byte;
|
|
|
|
break;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
case I2C_SMBUS_WORD_DATA:
|
|
|
|
len = 2;
|
2006-01-18 14:41:50 -07:00
|
|
|
cur_word = cpu_to_le16(data->word);
|
|
|
|
buffer = (u8 *)&cur_word;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
2006-01-18 14:41:50 -07:00
|
|
|
|
2006-07-01 09:06:43 -06:00
|
|
|
case I2C_SMBUS_I2C_BLOCK_DATA:
|
2006-01-18 14:41:50 -07:00
|
|
|
len = data->block[0];
|
2006-07-01 09:06:43 -06:00
|
|
|
if (len == 0 || len > I2C_SMBUS_BLOCK_MAX)
|
|
|
|
return -EINVAL;
|
2006-01-18 14:41:50 -07:00
|
|
|
buffer = &data->block[1];
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
2006-01-18 14:41:50 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
default:
|
2006-01-18 14:41:50 -07:00
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-01-18 14:43:10 -07:00
|
|
|
dev_dbg(&adapter->dev,
|
|
|
|
"size=%d, address=0x%x, command=0x%x, len=%d, read=%d\n",
|
|
|
|
size, address, command, len, rw);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!len && rw == I2C_SMBUS_READ) {
|
2006-01-18 14:43:10 -07:00
|
|
|
dev_dbg(&adapter->dev, "zero length read\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2006-01-18 15:17:01 -07:00
|
|
|
mutex_lock(&iface->mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-01-18 14:44:04 -07:00
|
|
|
iface->address_byte = (address << 1) | rw;
|
2005-04-16 16:20:36 -06:00
|
|
|
iface->command = command;
|
|
|
|
iface->ptr = buffer;
|
|
|
|
iface->len = len;
|
|
|
|
iface->result = -EINVAL;
|
|
|
|
iface->needs_reset = 0;
|
|
|
|
|
|
|
|
outb(inb(ACBCTL1) | ACBCTL1_START, ACBCTL1);
|
|
|
|
|
|
|
|
if (size == I2C_SMBUS_QUICK || size == I2C_SMBUS_BYTE)
|
|
|
|
iface->state = state_quick;
|
|
|
|
else
|
|
|
|
iface->state = state_address;
|
|
|
|
|
|
|
|
while (iface->state != state_idle)
|
|
|
|
scx200_acb_poll(iface);
|
|
|
|
|
|
|
|
if (iface->needs_reset)
|
|
|
|
scx200_acb_reset(iface);
|
|
|
|
|
|
|
|
rc = iface->result;
|
|
|
|
|
2006-01-18 15:17:01 -07:00
|
|
|
mutex_unlock(&iface->mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (rc == 0 && size == I2C_SMBUS_WORD_DATA && rw == I2C_SMBUS_READ)
|
2006-01-18 14:41:50 -07:00
|
|
|
data->word = le16_to_cpu(cur_word);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#ifdef DEBUG
|
2006-01-18 14:43:10 -07:00
|
|
|
dev_dbg(&adapter->dev, "transfer done, result: %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (buffer) {
|
|
|
|
int i;
|
|
|
|
printk(" data:");
|
|
|
|
for (i = 0; i < len; ++i)
|
|
|
|
printk(" %02x", buffer[i]);
|
|
|
|
}
|
|
|
|
printk("\n");
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32 scx200_acb_func(struct i2c_adapter *adapter)
|
|
|
|
{
|
|
|
|
return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
|
|
|
|
I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
|
2006-07-01 09:06:43 -06:00
|
|
|
I2C_FUNC_SMBUS_I2C_BLOCK;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* For now, we only handle combined mode (smbus) */
|
2006-09-03 14:39:46 -06:00
|
|
|
static const struct i2c_algorithm scx200_acb_algorithm = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.smbus_xfer = scx200_acb_smbus_xfer,
|
|
|
|
.functionality = scx200_acb_func,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct scx200_acb_iface *scx200_acb_list;
|
2007-07-12 06:12:28 -06:00
|
|
|
static DEFINE_MUTEX(scx200_acb_list_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-11-27 13:59:38 -07:00
|
|
|
static int scx200_acb_probe(struct scx200_acb_iface *iface)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
u8 val;
|
|
|
|
|
|
|
|
/* Disable the ACCESS.bus device and Configure the SCL
|
2006-01-18 14:41:50 -07:00
|
|
|
frequency: 16 clock cycles */
|
2005-04-16 16:20:36 -06:00
|
|
|
outb(0x70, ACBCTL2);
|
|
|
|
|
|
|
|
if (inb(ACBCTL2) != 0x70) {
|
2012-10-05 14:23:52 -06:00
|
|
|
pr_debug("ACBCTL2 readback failed\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENXIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
outb(inb(ACBCTL1) | ACBCTL1_NMINTE, ACBCTL1);
|
|
|
|
|
|
|
|
val = inb(ACBCTL1);
|
|
|
|
if (val) {
|
2012-10-05 14:23:52 -06:00
|
|
|
pr_debug("disabled, but ACBCTL1=0x%02x\n", val);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENXIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
outb(inb(ACBCTL2) | ACBCTL2_ENABLE, ACBCTL2);
|
|
|
|
|
|
|
|
outb(inb(ACBCTL1) | ACBCTL1_NMINTE, ACBCTL1);
|
|
|
|
|
|
|
|
val = inb(ACBCTL1);
|
|
|
|
if ((val & ACBCTL1_NMINTE) != ACBCTL1_NMINTE) {
|
2012-10-05 14:23:52 -06:00
|
|
|
pr_debug("enabled, but NMINTE won't be set, ACBCTL1=0x%02x\n",
|
|
|
|
val);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENXIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-11-27 13:59:38 -07:00
|
|
|
static struct scx200_acb_iface *scx200_create_iface(const char *text,
|
2007-02-13 14:09:03 -07:00
|
|
|
struct device *dev, int index)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct scx200_acb_iface *iface;
|
|
|
|
struct i2c_adapter *adapter;
|
|
|
|
|
2005-10-17 15:09:43 -06:00
|
|
|
iface = kzalloc(sizeof(*iface), GFP_KERNEL);
|
2014-05-12 19:51:58 -06:00
|
|
|
if (!iface)
|
2006-06-12 13:44:28 -06:00
|
|
|
return NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
adapter = &iface->adapter;
|
|
|
|
i2c_set_adapdata(adapter, iface);
|
2007-05-01 15:26:28 -06:00
|
|
|
snprintf(adapter->name, sizeof(adapter->name), "%s ACB%d", text, index);
|
2005-04-16 16:20:36 -06:00
|
|
|
adapter->owner = THIS_MODULE;
|
|
|
|
adapter->algo = &scx200_acb_algorithm;
|
2008-07-14 14:38:29 -06:00
|
|
|
adapter->class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
|
2007-02-13 14:09:03 -07:00
|
|
|
adapter->dev.parent = dev;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-01-18 15:17:01 -07:00
|
|
|
mutex_init(&iface->mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-06-12 13:44:28 -06:00
|
|
|
return iface;
|
|
|
|
}
|
|
|
|
|
2012-11-27 13:59:38 -07:00
|
|
|
static int scx200_acb_create(struct scx200_acb_iface *iface)
|
2006-06-12 13:44:28 -06:00
|
|
|
{
|
|
|
|
struct i2c_adapter *adapter;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
adapter = &iface->adapter;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
rc = scx200_acb_probe(iface);
|
|
|
|
if (rc) {
|
2012-10-05 14:23:52 -06:00
|
|
|
pr_warn("probe failed\n");
|
2006-06-12 13:44:28 -06:00
|
|
|
return rc;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
scx200_acb_reset(iface);
|
|
|
|
|
|
|
|
if (i2c_add_adapter(adapter) < 0) {
|
2012-10-05 14:23:52 -06:00
|
|
|
pr_err("failed to register\n");
|
2006-06-12 13:44:28 -06:00
|
|
|
return -ENODEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2010-12-30 21:27:33 -07:00
|
|
|
if (!adapter->dev.parent) {
|
|
|
|
/* If there's no dev, we're tracking (ISA) ifaces manually */
|
|
|
|
mutex_lock(&scx200_acb_list_mutex);
|
|
|
|
iface->next = scx200_acb_list;
|
|
|
|
scx200_acb_list = iface;
|
|
|
|
mutex_unlock(&scx200_acb_list_mutex);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return 0;
|
2006-06-12 13:44:28 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-11-27 13:59:38 -07:00
|
|
|
static struct scx200_acb_iface *scx200_create_dev(const char *text,
|
2010-12-30 21:27:33 -07:00
|
|
|
unsigned long base, int index, struct device *dev)
|
2006-06-12 13:44:28 -06:00
|
|
|
{
|
|
|
|
struct scx200_acb_iface *iface;
|
|
|
|
int rc;
|
|
|
|
|
2010-12-30 21:27:33 -07:00
|
|
|
iface = scx200_create_iface(text, dev, index);
|
2006-06-12 13:44:28 -06:00
|
|
|
|
|
|
|
if (iface == NULL)
|
2010-12-30 21:27:33 -07:00
|
|
|
return NULL;
|
2006-06-12 13:44:28 -06:00
|
|
|
|
2010-12-30 21:27:33 -07:00
|
|
|
if (!request_region(base, 8, iface->adapter.name)) {
|
2012-10-05 14:23:52 -06:00
|
|
|
pr_err("can't allocate io 0x%lx-0x%lx\n", base, base + 8 - 1);
|
2006-06-12 13:44:28 -06:00
|
|
|
goto errout_free;
|
|
|
|
}
|
|
|
|
|
2010-12-30 21:27:33 -07:00
|
|
|
iface->base = base;
|
2006-06-12 13:44:28 -06:00
|
|
|
rc = scx200_acb_create(iface);
|
|
|
|
|
|
|
|
if (rc == 0)
|
2010-12-30 21:27:33 -07:00
|
|
|
return iface;
|
2006-06-12 13:44:28 -06:00
|
|
|
|
2010-12-30 21:27:33 -07:00
|
|
|
release_region(base, 8);
|
2006-01-18 14:44:04 -07:00
|
|
|
errout_free:
|
|
|
|
kfree(iface);
|
2010-12-30 21:27:33 -07:00
|
|
|
return NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2012-11-27 13:59:38 -07:00
|
|
|
static int scx200_probe(struct platform_device *pdev)
|
2006-06-12 13:44:28 -06:00
|
|
|
{
|
|
|
|
struct scx200_acb_iface *iface;
|
2010-12-30 21:27:33 -07:00
|
|
|
struct resource *res;
|
2006-06-12 13:44:28 -06:00
|
|
|
|
2010-12-30 21:27:33 -07:00
|
|
|
res = platform_get_resource(pdev, IORESOURCE_IO, 0);
|
|
|
|
if (!res) {
|
|
|
|
dev_err(&pdev->dev, "can't fetch device resource info\n");
|
|
|
|
return -ENODEV;
|
2006-06-12 13:44:28 -06:00
|
|
|
}
|
|
|
|
|
2010-12-30 21:27:33 -07:00
|
|
|
iface = scx200_create_dev("CS5535", res->start, 0, &pdev->dev);
|
|
|
|
if (!iface)
|
|
|
|
return -EIO;
|
2006-06-12 13:44:28 -06:00
|
|
|
|
2010-12-30 21:27:33 -07:00
|
|
|
dev_info(&pdev->dev, "SCx200 device '%s' registered\n",
|
|
|
|
iface->adapter.name);
|
|
|
|
platform_set_drvdata(pdev, iface);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-12-30 21:27:33 -07:00
|
|
|
return 0;
|
2006-06-12 13:44:28 -06:00
|
|
|
}
|
|
|
|
|
2012-11-27 13:59:38 -07:00
|
|
|
static void scx200_cleanup_iface(struct scx200_acb_iface *iface)
|
2010-12-30 21:27:33 -07:00
|
|
|
{
|
|
|
|
i2c_del_adapter(&iface->adapter);
|
|
|
|
release_region(iface->base, 8);
|
|
|
|
kfree(iface);
|
|
|
|
}
|
2006-01-18 14:48:26 -07:00
|
|
|
|
2012-11-27 13:59:38 -07:00
|
|
|
static int scx200_remove(struct platform_device *pdev)
|
2006-01-18 14:48:26 -07:00
|
|
|
{
|
2010-12-30 21:27:33 -07:00
|
|
|
struct scx200_acb_iface *iface;
|
2006-06-12 13:44:28 -06:00
|
|
|
|
2010-12-30 21:27:33 -07:00
|
|
|
iface = platform_get_drvdata(pdev);
|
|
|
|
scx200_cleanup_iface(iface);
|
2006-06-12 13:44:28 -06:00
|
|
|
|
2010-12-30 21:27:33 -07:00
|
|
|
return 0;
|
|
|
|
}
|
2006-06-12 13:44:28 -06:00
|
|
|
|
2011-10-30 06:47:25 -06:00
|
|
|
static struct platform_driver scx200_pci_driver = {
|
2010-12-30 21:27:33 -07:00
|
|
|
.driver = {
|
|
|
|
.name = "cs5535-smb",
|
|
|
|
},
|
|
|
|
.probe = scx200_probe,
|
2012-11-27 13:59:38 -07:00
|
|
|
.remove = scx200_remove,
|
2010-12-30 21:27:33 -07:00
|
|
|
};
|
2006-06-12 13:44:28 -06:00
|
|
|
|
2013-12-02 16:11:20 -07:00
|
|
|
static const struct pci_device_id scx200_isa[] = {
|
2010-12-30 21:27:33 -07:00
|
|
|
{ PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SCx200_BRIDGE) },
|
|
|
|
{ PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SC1100_BRIDGE) },
|
|
|
|
{ 0, }
|
|
|
|
};
|
2006-06-12 13:44:28 -06:00
|
|
|
|
2010-12-30 21:27:33 -07:00
|
|
|
static __init void scx200_scan_isa(void)
|
|
|
|
{
|
|
|
|
int i;
|
2006-06-12 13:44:28 -06:00
|
|
|
|
2010-12-30 21:27:33 -07:00
|
|
|
if (!pci_dev_present(scx200_isa))
|
|
|
|
return;
|
2006-06-12 13:44:28 -06:00
|
|
|
|
2010-12-30 21:27:33 -07:00
|
|
|
for (i = 0; i < MAX_DEVICES; ++i) {
|
|
|
|
if (base[i] == 0)
|
|
|
|
continue;
|
2006-01-18 14:48:26 -07:00
|
|
|
|
2010-12-30 21:27:33 -07:00
|
|
|
/* XXX: should we care about failures? */
|
|
|
|
scx200_create_dev("SCx200", base[i], i, NULL);
|
2006-01-18 14:48:26 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static int __init scx200_acb_init(void)
|
|
|
|
{
|
2012-10-05 14:23:52 -06:00
|
|
|
pr_debug("NatSemi SCx200 ACCESS.bus Driver\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-12-30 21:27:33 -07:00
|
|
|
/* First scan for ISA-based devices */
|
|
|
|
scx200_scan_isa(); /* XXX: should we care about errors? */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-04-26 14:50:32 -06:00
|
|
|
/* If at least one bus was created, init must succeed */
|
|
|
|
if (scx200_acb_list)
|
|
|
|
return 0;
|
2010-12-30 21:27:33 -07:00
|
|
|
|
|
|
|
/* No ISA devices; register the platform driver for PCI-based devices */
|
2011-10-30 06:47:25 -06:00
|
|
|
return platform_driver_register(&scx200_pci_driver);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit scx200_acb_cleanup(void)
|
|
|
|
{
|
|
|
|
struct scx200_acb_iface *iface;
|
2006-01-18 14:41:50 -07:00
|
|
|
|
2011-10-30 06:47:25 -06:00
|
|
|
platform_driver_unregister(&scx200_pci_driver);
|
2010-12-30 21:27:33 -07:00
|
|
|
|
2007-07-12 06:12:28 -06:00
|
|
|
mutex_lock(&scx200_acb_list_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
while ((iface = scx200_acb_list) != NULL) {
|
|
|
|
scx200_acb_list = iface->next;
|
2007-07-12 06:12:28 -06:00
|
|
|
mutex_unlock(&scx200_acb_list_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-12-30 21:27:33 -07:00
|
|
|
scx200_cleanup_iface(iface);
|
2006-06-12 13:44:28 -06:00
|
|
|
|
2007-07-12 06:12:28 -06:00
|
|
|
mutex_lock(&scx200_acb_list_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-07-12 06:12:28 -06:00
|
|
|
mutex_unlock(&scx200_acb_list_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
module_init(scx200_acb_init);
|
|
|
|
module_exit(scx200_acb_cleanup);
|