NetBSD-5.0.2/sys/arch/i386/pci/viapcib.c
/* $NetBSD: viapcib.c,v 1.11 2008/07/20 16:59:53 martin Exp $ */
/* $FreeBSD: src/sys/pci/viapm.c,v 1.10 2005/05/29 04:42:29 nyan Exp $ */
/*-
* Copyright (c) 2005, 2006 Jared D. McNeill <jmcneill@invisible.ca>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions, and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/*-
* Copyright (c) 2001 Alcove - Nicolas Souchu
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: viapcib.c,v 1.11 2008/07/20 16:59:53 martin Exp $");
#include <sys/types.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/proc.h>
#include <sys/simplelock.h>
#include <sys/bus.h>
#include <dev/pci/pcireg.h>
#include <dev/pci/pcivar.h>
#include <dev/pci/pcidevs.h>
#include <dev/i2c/i2cvar.h>
#include <i386/pci/viapcibreg.h>
#include <x86/pci/pcibvar.h>
/*#define VIAPCIB_DEBUG*/
#ifdef VIAPCIB_DEBUG
#define DPRINTF(x) printf x
#else
#define DPRINTF(x)
#endif
struct viapcib_softc {
/* we call pcibattach(), which assumes softc starts like this: */
struct pcib_softc sc_pcib;
bus_space_tag_t sc_iot;
bus_space_handle_t sc_ioh;
struct i2c_controller sc_i2c;
int sc_revision;
struct simplelock sc_lock;
};
static int viapcib_match(device_t, cfdata_t, void *);
static void viapcib_attach(device_t, device_t, void *);
static int viapcib_clear(struct viapcib_softc *);
static int viapcib_busy(struct viapcib_softc *);
#define viapcib_smbus_read(sc, o) \
bus_space_read_1((sc)->sc_iot, (sc)->sc_ioh, (o))
#define viapcib_smbus_write(sc, o, v) \
bus_space_write_1((sc)->sc_iot, (sc)->sc_ioh, (o), (v))
#define VIAPCIB_SMBUS_TIMEOUT 10000
static int viapcib_acquire_bus(void *, int);
static void viapcib_release_bus(void *, int);
static int viapcib_exec(void *, i2c_op_t, i2c_addr_t, const void *,
size_t, void *, size_t, int);
/* SMBus operations */
static int viapcib_smbus_quick_write(void *, i2c_addr_t);
static int viapcib_smbus_quick_read(void *, i2c_addr_t);
static int viapcib_smbus_send_byte(void *, i2c_addr_t, uint8_t);
static int viapcib_smbus_receive_byte(void *, i2c_addr_t,
uint8_t *);
static int viapcib_smbus_read_byte(void *, i2c_addr_t, uint8_t,
int8_t *);
static int viapcib_smbus_write_byte(void *, i2c_addr_t, uint8_t,
int8_t);
static int viapcib_smbus_read_word(void *, i2c_addr_t, uint8_t,
int16_t *);
static int viapcib_smbus_write_word(void *, i2c_addr_t, uint8_t,
int16_t);
static int viapcib_smbus_block_write(void *, i2c_addr_t, uint8_t,
int, void *);
static int viapcib_smbus_block_read(void *, i2c_addr_t, uint8_t,
int, void *);
/* XXX Should be moved to smbus layer */
#define SMB_MAXBLOCKSIZE 32
CFATTACH_DECL_NEW(viapcib, sizeof(struct viapcib_softc),
viapcib_match, viapcib_attach, NULL, NULL);
static int
viapcib_match(device_t parent, cfdata_t match, void *opaque)
{
struct pci_attach_args *pa = opaque;
if (PCI_VENDOR(pa->pa_id) != PCI_VENDOR_VIATECH)
return 0;
switch (PCI_PRODUCT(pa->pa_id)) {
case PCI_PRODUCT_VIATECH_VT8235:
case PCI_PRODUCT_VIATECH_VT8237:
return 2; /* match above generic pcib(4) */
}
return 0;
}
static void
viapcib_attach(device_t parent, device_t self, void *opaque)
{
struct viapcib_softc *sc = device_private(self);
struct pci_attach_args *pa = opaque;
pcireg_t addr, val;
/* XXX Only the 8235 is supported for now */
sc->sc_iot = pa->pa_iot;
addr = pci_conf_read(pa->pa_pc, pa->pa_tag, SMB_BASE3);
addr &= 0xfff0;
if (bus_space_map(sc->sc_iot, addr, 8, 0, &sc->sc_ioh)) {
printf(": failed to map SMBus I/O space\n");
addr = 0;
goto core_pcib;
}
simple_lock_init(&sc->sc_lock);
val = pci_conf_read(pa->pa_pc, pa->pa_tag, SMB_HOST_CONFIG);
if ((val & 0x10000) == 0) {
printf(": SMBus is disabled\n");
addr = 0;
/* XXX We can enable the SMBus here by writing 1 to
* SMB_HOST_CONFIG, but do we want to?
*/
goto core_pcib;
}
#ifdef VIAPCIB_DEBUG
switch (val & 0x0e) {
case 8:
printf(": interrupting at irq 9\n");
break;
case 0:
printf(": interrupting at SMI#\n");
break;
default:
printf(": interrupt misconfigured\n");
break;
}
#endif /* !VIAPCIB_DEBUG */
val = pci_conf_read(pa->pa_pc, pa->pa_tag, SMB_REVISION);
sc->sc_revision = val >> 16;
core_pcib:
pcibattach(parent, self, opaque);
if (addr != 0) {
struct i2cbus_attach_args iba;
uint8_t b;
printf("%s: SMBus found at 0x%x (revision 0x%x)\n",
device_xname(self), addr, sc->sc_revision);
/* Disable slave function */
b = viapcib_smbus_read(sc, SMBSLVCNT);
viapcib_smbus_write(sc, SMBSLVCNT, b & ~1);
memset(&sc->sc_i2c, 0, sizeof(sc->sc_i2c));
#ifdef I2C_TYPE_SMBUS
iba.iba_type = I2C_TYPE_SMBUS;
#endif
iba.iba_tag = &sc->sc_i2c;
iba.iba_tag->ic_cookie = (void *)sc;
iba.iba_tag->ic_acquire_bus = viapcib_acquire_bus;
iba.iba_tag->ic_release_bus = viapcib_release_bus;
iba.iba_tag->ic_exec = viapcib_exec;
config_found_ia(self, "i2cbus", &iba, iicbus_print);
}
}
static int
viapcib_wait(struct viapcib_softc *sc)
{
int rv, timeout;
uint8_t val;
timeout = VIAPCIB_SMBUS_TIMEOUT;
rv = 0;
while (timeout--) {
val = viapcib_smbus_read(sc, SMBHSTSTS);
if (!(val & SMBHSTSTS_BUSY) && (val & SMBHSTSTS_INTR))
break;
DELAY(10);
}
if (timeout == 0)
rv = EBUSY;
if ((val & SMBHSTSTS_FAILED) || (val & SMBHSTSTS_COLLISION) ||
(val & SMBHSTSTS_ERROR))
rv = EIO;
viapcib_clear(sc);
return rv;
}
static int
viapcib_clear(struct viapcib_softc *sc)
{
viapcib_smbus_write(sc, SMBHSTSTS,
(SMBHSTSTS_FAILED | SMBHSTSTS_COLLISION | SMBHSTSTS_ERROR |
SMBHSTSTS_INTR));
DELAY(10);
return 0;
}
static int
viapcib_busy(struct viapcib_softc *sc)
{
uint8_t val;
val = viapcib_smbus_read(sc, SMBHSTSTS);
return (val & SMBHSTSTS_BUSY);
}
static int
viapcib_acquire_bus(void *opaque, int flags)
{
struct viapcib_softc *sc;
DPRINTF(("viapcib_i2c_acquire_bus(%p, 0x%x)\n", opaque, flags));
sc = (struct viapcib_softc *)opaque;
simple_lock(&sc->sc_lock);
return 0;
}
static void
viapcib_release_bus(void *opaque, int flags)
{
struct viapcib_softc *sc;
DPRINTF(("viapcib_i2c_release_bus(%p, 0x%x)\n", opaque, flags));
sc = (struct viapcib_softc *)opaque;
simple_unlock(&sc->sc_lock);
return;
}
static int
viapcib_exec(void *opaque, i2c_op_t op, i2c_addr_t addr, const void *vcmd,
size_t cmdlen, void *vbuf, size_t buflen, int flags)
{
struct viapcib_softc *sc;
uint8_t cmd;
int rv = -1;
DPRINTF(("viapcib_exec(%p, 0x%x, 0x%x, %p, %d, %p, %d, 0x%x)\n",
opaque, op, addr, vcmd, cmdlen, vbuf, buflen, flags));
sc = (struct viapcib_softc *)opaque;
if (op != I2C_OP_READ_WITH_STOP &&
op != I2C_OP_WRITE_WITH_STOP)
return -1;
if (cmdlen > 0)
cmd = *(uint8_t *)(__UNCONST(vcmd)); /* XXX */
switch (cmdlen) {
case 0:
switch (buflen) {
case 0:
/* SMBus quick read/write */
if (I2C_OP_READ_P(op))
rv = viapcib_smbus_quick_read(sc, addr);
else
rv = viapcib_smbus_quick_write(sc, addr);
return rv;
case 1:
/* SMBus send/receive byte */
if (I2C_OP_READ_P(op))
rv = viapcib_smbus_send_byte(sc, addr,
*(uint8_t *)vbuf);
else
rv = viapcib_smbus_receive_byte(sc, addr,
(uint8_t *)vbuf);
return rv;
default:
return -1;
}
case 1:
switch (buflen) {
case 0:
return -1;
case 1:
/* SMBus read/write byte */
if (I2C_OP_READ_P(op))
rv = viapcib_smbus_read_byte(sc, addr,
cmd, (uint8_t *)vbuf);
else
rv = viapcib_smbus_write_byte(sc, addr,
cmd, *(uint8_t *)vbuf);
return rv;
case 2:
/* SMBus read/write word */
if (I2C_OP_READ_P(op))
rv = viapcib_smbus_read_word(sc, addr,
cmd, (uint16_t *)vbuf);
else
rv = viapcib_smbus_write_word(sc, addr,
cmd, *(uint16_t *)vbuf);
return rv;
default:
/* SMBus read/write block */
if (I2C_OP_READ_P(op))
rv = viapcib_smbus_block_read(sc, addr,
cmd, buflen, vbuf);
else
rv = viapcib_smbus_block_write(sc, addr,
cmd, buflen, vbuf);
return rv;
}
}
return -1; /* XXX ??? */
}
static int
viapcib_smbus_quick_write(void *opaque, i2c_addr_t slave)
{
struct viapcib_softc *sc;
sc = (struct viapcib_softc *)opaque;
DPRINTF(("viapcib_smbus_quick_write(%p, 0x%x)\n", opaque, slave));
viapcib_clear(sc);
if (viapcib_busy(sc))
return EBUSY;
viapcib_smbus_write(sc, SMBHSTADD, (slave & 0x7f) << 1);
viapcib_smbus_write(sc, SMBHSTCNT, SMBHSTCNT_QUICK);
if (viapcib_wait(sc))
return EBUSY;
viapcib_smbus_write(sc, SMBHSTCNT, SMBHSTCNT_QUICK | SMBHSTCNT_START);
return viapcib_wait(sc);
}
static int
viapcib_smbus_quick_read(void *opaque, i2c_addr_t slave)
{
struct viapcib_softc *sc;
sc = (struct viapcib_softc *)opaque;
DPRINTF(("viapcib_smbus_quick_read(%p, 0x%x)\n", opaque, slave));
viapcib_clear(sc);
if (viapcib_busy(sc))
return EBUSY;
viapcib_smbus_write(sc, SMBHSTADD, ((slave & 0x7f) << 1) | 1);
viapcib_smbus_write(sc, SMBHSTCNT, SMBHSTCNT_QUICK);
if (viapcib_wait(sc))
return EBUSY;
viapcib_smbus_write(sc, SMBHSTCNT, SMBHSTCNT_QUICK | SMBHSTCNT_START);
return viapcib_wait(sc);
}
static int
viapcib_smbus_send_byte(void *opaque, i2c_addr_t slave, uint8_t byte)
{
struct viapcib_softc *sc;
sc = (struct viapcib_softc *)opaque;
DPRINTF(("viapcib_smbus_send_byte(%p, 0x%x, 0x%x)\n", opaque,
slave, byte));
viapcib_clear(sc);
if (viapcib_busy(sc))
return EBUSY;
viapcib_smbus_write(sc, SMBHSTADD, (slave & 0x7f) << 1);
viapcib_smbus_write(sc, SMBHSTCMD, byte);
viapcib_smbus_write(sc, SMBHSTCNT, SMBHSTCNT_SENDRECV);
if (viapcib_wait(sc))
return EBUSY;
viapcib_smbus_write(sc, SMBHSTCNT,
SMBHSTCNT_START | SMBHSTCNT_SENDRECV);
return viapcib_wait(sc);
}
static int
viapcib_smbus_receive_byte(void *opaque, i2c_addr_t slave, uint8_t *pbyte)
{
struct viapcib_softc *sc;
int rv;
sc = (struct viapcib_softc *)opaque;
DPRINTF(("viapcib_smbus_receive_byte(%p, 0x%x, %p)\n", opaque,
slave, pbyte));
viapcib_clear(sc);
if (viapcib_busy(sc))
return EBUSY;
viapcib_smbus_write(sc, SMBHSTADD, ((slave & 0x7f) << 1) | 1);
viapcib_smbus_write(sc, SMBHSTCNT, SMBHSTCNT_SENDRECV);
if (viapcib_wait(sc))
return EBUSY;
viapcib_smbus_write(sc, SMBHSTCNT,
SMBHSTCNT_START | SMBHSTCNT_SENDRECV);
rv = viapcib_wait(sc);
if (rv == 0)
*pbyte = viapcib_smbus_read(sc, SMBHSTDAT0);
return rv;
}
static int
viapcib_smbus_write_byte(void *opaque, i2c_addr_t slave, uint8_t cmd,
int8_t byte)
{
struct viapcib_softc *sc;
sc = (struct viapcib_softc *)opaque;
DPRINTF(("viapcib_smbus_write_byte(%p, 0x%x, 0x%x, 0x%x)\n", opaque,
slave, cmd, byte));
viapcib_clear(sc);
if (viapcib_busy(sc))
return EBUSY;
viapcib_smbus_write(sc, SMBHSTADD, (slave & 0x7f) << 1);
viapcib_smbus_write(sc, SMBHSTCMD, cmd);
viapcib_smbus_write(sc, SMBHSTDAT0, byte);
viapcib_smbus_write(sc, SMBHSTCNT, SMBHSTCNT_BYTE);
if (viapcib_wait(sc))
return EBUSY;
viapcib_smbus_write(sc, SMBHSTCNT, SMBHSTCNT_START | SMBHSTCNT_BYTE);
return viapcib_wait(sc);
}
static int
viapcib_smbus_read_byte(void *opaque, i2c_addr_t slave, uint8_t cmd,
int8_t *pbyte)
{
struct viapcib_softc *sc;
int rv;
sc = (struct viapcib_softc *)opaque;
DPRINTF(("viapcib_smbus_read_byte(%p, 0x%x, 0x%x, %p)\n", opaque,
slave, cmd, pbyte));
viapcib_clear(sc);
if (viapcib_busy(sc))
return EBUSY;
viapcib_smbus_write(sc, SMBHSTADD, ((slave & 0x7f) << 1) | 1);
viapcib_smbus_write(sc, SMBHSTCMD, cmd);
viapcib_smbus_write(sc, SMBHSTCNT, SMBHSTCNT_BYTE);
if (viapcib_wait(sc))
return EBUSY;
viapcib_smbus_write(sc, SMBHSTCNT, SMBHSTCNT_START | SMBHSTCNT_BYTE);
rv = viapcib_wait(sc);
if (rv == 0)
*pbyte = viapcib_smbus_read(sc, SMBHSTDAT0);
return rv;
}
static int
viapcib_smbus_write_word(void *opaque, i2c_addr_t slave, uint8_t cmd,
int16_t word)
{
struct viapcib_softc *sc;
sc = (struct viapcib_softc *)opaque;
DPRINTF(("viapcib_smbus_write_word(%p, 0x%x, 0x%x, 0x%x)\n", opaque,
slave, cmd, word));
viapcib_clear(sc);
if (viapcib_busy(sc))
return EBUSY;
viapcib_smbus_write(sc, SMBHSTADD, (slave & 0x7f) << 1);
viapcib_smbus_write(sc, SMBHSTCMD, cmd);
viapcib_smbus_write(sc, SMBHSTDAT0, word & 0x00ff);
viapcib_smbus_write(sc, SMBHSTDAT1, (word & 0xff00) >> 8);
viapcib_smbus_write(sc, SMBHSTCNT, SMBHSTCNT_WORD);
if (viapcib_wait(sc))
return EBUSY;
viapcib_smbus_write(sc, SMBHSTCNT, SMBHSTCNT_START | SMBHSTCNT_WORD);
return viapcib_wait(sc);
}
static int
viapcib_smbus_read_word(void *opaque, i2c_addr_t slave, uint8_t cmd,
int16_t *pword)
{
struct viapcib_softc *sc;
int rv;
int8_t high, low;
sc = (struct viapcib_softc *)opaque;
DPRINTF(("viapcib_smbus_read_word(%p, 0x%x, 0x%x, %p)\n", opaque,
slave, cmd, pword));
viapcib_clear(sc);
if (viapcib_busy(sc))
return EBUSY;
viapcib_smbus_write(sc, SMBHSTADD, ((slave & 0x7f) << 1) | 1);
viapcib_smbus_write(sc, SMBHSTCMD, cmd);
viapcib_smbus_write(sc, SMBHSTCNT, SMBHSTCNT_WORD);
if (viapcib_wait(sc))
return EBUSY;
viapcib_smbus_write(sc, SMBHSTCNT, SMBHSTCNT_START | SMBHSTCNT_WORD);
rv = viapcib_wait(sc);
if (rv == 0) {
low = viapcib_smbus_read(sc, SMBHSTDAT0);
high = viapcib_smbus_read(sc, SMBHSTDAT1);
*pword = ((high & 0xff) << 8) | (low & 0xff);
}
return rv;
}
static int
viapcib_smbus_block_write(void *opaque, i2c_addr_t slave, uint8_t cmd,
int cnt, void *data)
{
struct viapcib_softc *sc;
int8_t *buf;
int remain, len, i;
int rv;
sc = (struct viapcib_softc *)opaque;
buf = (int8_t *)data;
rv = 0;
DPRINTF(("viapcib_smbus_block_write(%p, 0x%x, 0x%x, %d, %p)\n",
opaque, slave, cmd, cnt, data));
viapcib_clear(sc);
if (viapcib_busy(sc))
return EBUSY;
remain = cnt;
while (remain) {
len = min(remain, SMB_MAXBLOCKSIZE);
viapcib_smbus_write(sc, SMBHSTADD, (slave & 0x7f) << 1);
viapcib_smbus_write(sc, SMBHSTCMD, cmd);
viapcib_smbus_write(sc, SMBHSTDAT0, len);
i = viapcib_smbus_read(sc, SMBHSTCNT);
/* XXX FreeBSD does this, but it looks wrong */
for (i = 0; i < len; i++) {
viapcib_smbus_write(sc, SMBBLKDAT,
buf[cnt - remain + i]);
}
viapcib_smbus_write(sc, SMBHSTCNT, SMBHSTCNT_BLOCK);
if (viapcib_wait(sc))
return EBUSY;
viapcib_smbus_write(sc, SMBHSTCNT,
SMBHSTCNT_START | SMBHSTCNT_BLOCK);
if (viapcib_wait(sc))
return EBUSY;
remain -= len;
}
return rv;
}
static int
viapcib_smbus_block_read(void *opaque, i2c_addr_t slave, uint8_t cmd,
int cnt, void *data)
{
struct viapcib_softc *sc;
int8_t *buf;
int remain, len, i;
int rv;
sc = (struct viapcib_softc *)opaque;
buf = (int8_t *)data;
rv = 0;
DPRINTF(("viapcib_smbus_block_read(%p, 0x%x, 0x%x, %d, %p)\n",
opaque, slave, cmd, cnt, data));
viapcib_clear(sc);
if (viapcib_busy(sc))
return EBUSY;
remain = cnt;
while (remain) {
viapcib_smbus_write(sc, SMBHSTADD, ((slave & 0x7f) << 1) | 1);
viapcib_smbus_write(sc, SMBHSTCMD, cmd);
viapcib_smbus_write(sc, SMBHSTCNT, SMBHSTCNT_BLOCK);
if (viapcib_wait(sc))
return EBUSY;
viapcib_smbus_write(sc, SMBHSTCNT,
SMBHSTCNT_START | SMBHSTCNT_BLOCK);
if (viapcib_wait(sc))
return EBUSY;
len = viapcib_smbus_read(sc, SMBHSTDAT0);
i = viapcib_smbus_read(sc, SMBHSTCNT);
len = min(len, remain);
/* FreeBSD does this too... */
for (i = 0; i < len; i++) {
buf[cnt - remain + i] =
viapcib_smbus_read(sc, SMBBLKDAT);
}
remain -= len;
}
return rv;
}