From d70424edcbc5826900198fd3ecd4abe0a06887cd Mon Sep 17 00:00:00 2001 From: Nicolas Souchu Date: Thu, 3 Sep 1998 20:52:54 +0000 Subject: [PATCH] Submitted by: nsouch System Management Bus generic support over new bus architecture. --- sys/dev/smbus/smb.c | 287 +++++++++++++++++++++++++++++++++++++++ sys/dev/smbus/smbconf.c | 157 +++++++++++++++++++++ sys/dev/smbus/smbconf.h | 91 +++++++++++++ sys/dev/smbus/smbus.c | 157 +++++++++++++++++++++ sys/dev/smbus/smbus.h | 41 ++++++ sys/dev/smbus/smbus_if.m | 140 +++++++++++++++++++ 6 files changed, 873 insertions(+) create mode 100644 sys/dev/smbus/smb.c create mode 100644 sys/dev/smbus/smbconf.c create mode 100644 sys/dev/smbus/smbconf.h create mode 100644 sys/dev/smbus/smbus.c create mode 100644 sys/dev/smbus/smbus.h create mode 100644 sys/dev/smbus/smbus_if.m diff --git a/sys/dev/smbus/smb.c b/sys/dev/smbus/smb.c new file mode 100644 index 000000000000..5a19dcb47eee --- /dev/null +++ b/sys/dev/smbus/smb.c @@ -0,0 +1,287 @@ +/*- + * Copyright (c) 1998 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. + * + * $Id: smb.c,v 1.1.2.1 1998/08/13 15:15:19 son Exp $ + * + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include + +#include "smbus_if.h" + +#define BUFSIZE 1024 + +struct smb_softc { + + int sc_addr; /* address on smbus */ + int sc_count; /* >0 if device opened */ + + char *sc_cp; /* output buffer pointer */ + + char sc_buffer[BUFSIZE]; /* output buffer */ + char sc_inbuf[BUFSIZE]; /* input buffer */ +}; + +#define IIC_SOFTC(unit) \ + ((struct smb_softc *)devclass_get_softc(smb_devclass, (unit))) + +#define IIC_DEVICE(unit) \ + (devclass_get_device(smb_devclass, (unit))) + +static int smb_probe(device_t); +static int smb_attach(device_t); + +static devclass_t smb_devclass; + +static device_method_t smb_methods[] = { + /* device interface */ + DEVMETHOD(device_probe, smb_probe), + DEVMETHOD(device_attach, smb_attach), + + /* smbus interface */ + DEVMETHOD(smbus_intr, smbus_generic_intr), + + { 0, 0 } +}; + +static driver_t smb_driver = { + "smb", + smb_methods, + DRIVER_TYPE_MISC, + sizeof(struct smb_softc), +}; + +static d_open_t smbopen; +static d_close_t smbclose; +static d_write_t smbwrite; +static d_read_t smbread; +static d_ioctl_t smbioctl; + +#define CDEV_MAJOR 73 +static struct cdevsw smb_cdevsw = + { smbopen, smbclose, smbread, smbwrite, /*73*/ + smbioctl, nullstop, nullreset, nodevtotty, /*smb*/ + seltrue, nommap, nostrat, "smb", NULL, -1 }; + +/* + * smbprobe() + */ +static int +smb_probe(device_t dev) +{ + struct smb_softc *sc = (struct smb_softc *)device_get_softc(dev); + + sc->sc_addr = smbus_get_addr(dev); + + /* XXX detect chip with start/stop conditions */ + + return (0); +} + +/* + * smbattach() + */ +static int +smb_attach(device_t dev) +{ + struct smb_softc *sc = (struct smb_softc *)device_get_softc(dev); + + return (0); +} + +static int +smbopen (dev_t dev, int flags, int fmt, struct proc *p) +{ + struct smb_softc *sc = IIC_SOFTC(minor(dev)); + + if (!sc) + return (EINVAL); + + if (sc->sc_count) + return (EBUSY); + + sc->sc_count++; + + return (0); +} + +static int +smbclose(dev_t dev, int flags, int fmt, struct proc *p) +{ + struct smb_softc *sc = IIC_SOFTC(minor(dev)); + + if (!sc) + return (EINVAL); + + if (!sc->sc_count) + return (EINVAL); + + sc->sc_count--; + + return (0); +} + +static int +smbwrite(dev_t dev, struct uio * uio, int ioflag) +{ + device_t smbdev = IIC_DEVICE(minor(dev)); + struct smb_softc *sc = IIC_SOFTC(minor(dev)); + int error, count; + + if (!sc || !smbdev) + return (EINVAL); + + if (sc->sc_count == 0) + return (EINVAL); + + count = min(uio->uio_resid, BUFSIZE); + uiomove(sc->sc_buffer, count, uio); + + /* we consider the command char as the first character to send */ + smbus_bwrite(device_get_parent(smbdev), sc->sc_addr, + sc->sc_buffer[0], count-1, sc->sc_buffer+1); + + return (0); +} + +static int +smbread(dev_t dev, struct uio * uio, int ioflag) +{ + /* not supported */ + + return (EINVAL); +} + +static int +smbioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct proc *p) +{ + device_t smbdev = IIC_DEVICE(minor(dev)); + struct smb_softc *sc = IIC_SOFTC(minor(dev)); + device_t parent = device_get_parent(smbdev); + + int error = 0; + struct smbcmd *s = (struct smbcmd *)data; + + if (!sc) + return (EINVAL); + + switch (cmd) { + case SMB_QUICK_WRITE: + smbus_quick(parent, sc->sc_addr, SMB_QWRITE); + goto end; + + case SMB_QUICK_READ: + smbus_quick(parent, sc->sc_addr, SMB_QREAD); + goto end; + }; + + if (!s) + return (EINVAL); + + switch (cmd) { + case SMB_SENDB: + smbus_sendb(parent, sc->sc_addr, s->cmd); + break; + + case SMB_RECVB: + smbus_recvb(parent, sc->sc_addr, &s->cmd); + break; + + case SMB_WRITEB: + smbus_writeb(parent, sc->sc_addr, s->cmd, s->data.byte); + break; + + case SMB_WRITEW: + smbus_writew(parent, sc->sc_addr, s->cmd, s->data.word); + break; + + case SMB_READB: + if (s->data.byte_ptr) + smbus_readb(parent, sc->sc_addr, s->cmd, + s->data.byte_ptr); + break; + + case SMB_READW: + if (s->data.word_ptr) + smbus_readw(parent, sc->sc_addr, s->cmd, s->data.word_ptr); + break; + + case SMB_PCALL: + if (s->data.process.rdata) + smbus_pcall(parent, sc->sc_addr, s->cmd, + s->data.process.sdata, s->data.process.rdata); + break; + + case SMB_BWRITE: + if (s->count && s->data.byte_ptr) + smbus_bwrite(parent, sc->sc_addr, s->cmd, s->count, + s->data.byte_ptr); + break; + + case SMB_BREAD: + if (s->count && s->data.byte_ptr) + smbus_bread(parent, sc->sc_addr, s->cmd, s->count, + s->data.byte_ptr); + break; + + default: + error = ENODEV; + } + +end: + return (error); +} + +static int smb_devsw_installed = 0; + +static void +smb_drvinit(void *unused) +{ + dev_t dev; + + if( ! smb_devsw_installed ) { + dev = makedev(CDEV_MAJOR,0); + cdevsw_add(&dev,&smb_cdevsw,NULL); + smb_devsw_installed = 1; + } +} + +CDEV_DRIVER_MODULE(smb, smbus, smb_driver, smb_devclass, CDEV_MAJOR, + smb_cdevsw, 0, 0); + +SYSINIT(smbdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,smb_drvinit,NULL) diff --git a/sys/dev/smbus/smbconf.c b/sys/dev/smbus/smbconf.c new file mode 100644 index 000000000000..60798f5c82dd --- /dev/null +++ b/sys/dev/smbus/smbconf.c @@ -0,0 +1,157 @@ +/*- + * Copyright (c) 1998 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. + * + * $Id: smbconf.c,v 1.1.1.2 1998/08/13 15:16:57 son Exp $ + * + */ +#include +#include +#include +#include +#include +#include + +#include +#include +#include "smbus_if.h" + +/* + * smbus_intr() + */ +void +smbus_intr(device_t bus, u_char devaddr, char low, char high, int error) +{ + struct smbus_softc *sc = (struct smbus_softc *)device_get_softc(bus); + + /* call owner's intr routine */ + if (sc->owner) + SMBUS_INTR(sc->owner, devaddr, low, high, error); + + return; +} + +/* + * smbus_alloc_bus() + * + * Allocate a new bus connected to the given parent device + */ +device_t +smbus_alloc_bus(device_t parent) +{ + device_t child; + + /* add the bus to the parent */ + child = device_add_child(parent, "smbus", -1, NULL); + + if (child) + device_set_desc(child, "System Management Bus"); + + return (child); +} + +/* + * smbus_request_bus() + * + * Allocate the device to perform transfers. + * + * how : SMB_WAIT or SMB_DONTWAIT + */ +int +smbus_request_bus(device_t bus, device_t dev, int how) +{ + struct smbus_softc *sc = (struct smbus_softc *)device_get_softc(bus); + int s, error = 0; + + while (!error) { + s = splhigh(); + if (sc->owner) { + splx(s); + + switch (how) { + case (SMB_WAIT | SMB_INTR): + error = tsleep(sc, SMBPRI|PCATCH, "smbreq", 0); + break; + + case (SMB_WAIT | SMB_NOINTR): + error = tsleep(sc, SMBPRI, "smbreq", 0); + break; + + default: + return (EWOULDBLOCK); + break; + } + + } else { + sc->owner = dev; + + splx(s); + return (0); + } + } + + return (error); +} + +/* + * smbus_release_bus() + * + * Release the device allocated with smbus_request_dev() + */ +int +smbus_release_bus(device_t bus, device_t dev) +{ + struct smbus_softc *sc = (struct smbus_softc *)device_get_softc(bus); + int s; + + s = splhigh(); + if (sc->owner != dev) { + splx(s); + return (EACCES); + } + + sc->owner = 0; + splx(s); + + /* wakeup waiting processes */ + wakeup(sc); + + return (0); +} + +/* + * smbus_get_addr() + * + * Get the I2C 7 bits address of the device + */ +u_char +smbus_get_addr(device_t dev) +{ + u_long addr; + device_t parent = device_get_parent(dev); + + BUS_READ_IVAR(parent, dev, SMBUS_IVAR_ADDR, &addr); + + return ((u_char)addr); +} diff --git a/sys/dev/smbus/smbconf.h b/sys/dev/smbus/smbconf.h new file mode 100644 index 000000000000..10fc3bcb011c --- /dev/null +++ b/sys/dev/smbus/smbconf.h @@ -0,0 +1,91 @@ +/*- + * Copyright (c) 1998 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. + * + * $Id: smbconf.h,v 1.1.1.2 1998/08/13 15:16:58 son Exp $ + */ +#ifndef __SMBONF_H +#define __SMBONF_H + +#include + +#define SMBPRI PZERO+8 /* XXX sleep/wakeup queue priority */ + +#define n(flags) (~(flags) & (flags)) + +/* + * How tsleep() is called in smb_request_bus(). + */ +#define SMB_DONTWAIT 0 +#define SMB_NOINTR 0 +#define SMB_WAIT 0x1 +#define SMB_INTR 0x2 + +/* + * SMB bus errors + */ +#define SMB_ENOERR 0x0 +#define SMB_EBUSERR 0x1 + +/* + * How Quick command is executed + */ +#define SMB_QWRITE 0x0 +#define SMB_QREAD 0x1 + +/* + * ivars codes + */ +#define SMBUS_IVAR_ADDR 0x1 /* I2C address of the device */ + +extern int smbus_request_bus(device_t, device_t, int); +extern int smbus_release_bus(device_t, device_t); +extern device_t smbus_alloc_bus(device_t); + +extern void smbus_intr(device_t, u_char, char low, char high, int error); + +extern u_char smbus_get_addr(device_t); + +#define smbus_quick(bus,slave,how) \ + (SMBUS_QUICK(device_get_parent(bus), slave, how)) +#define smbus_sendb(bus,slave,byte) \ + (SMBUS_SENDB(device_get_parent(bus), slave, byte)) +#define smbus_recvb(bus,slave,byte) \ + (SMBUS_RECVB(device_get_parent(bus), slave, byte)) +#define smbus_writeb(bus,slave,cmd,byte) \ + (SMBUS_WRITEB(device_get_parent(bus), slave, cmd, byte)) +#define smbus_writew(bus,slave,cmd,word) \ + (SMBUS_WRITEW(device_get_parent(bus), slave, cmd, word)) +#define smbus_readb(bus,slave,cmd,byte) \ + (SMBUS_READB(device_get_parent(bus), slave, cmd, byte)) +#define smbus_readw(bus,slave,cmd,word) \ + (SMBUS_READW(device_get_parent(bus), slave, cmd, word)) +#define smbus_pcall(bus,slave,cmd,sdata,rdata) \ + (SMBUS_PCALL(device_get_parent(bus), slave, cmd, sdata, rdata)) +#define smbus_bwrite(bus,slave,cmd,count,buf) \ + (SMBUS_BWRITE(device_get_parent(bus), slave, cmd, count, buf)) +#define smbus_bread(bus,slave,cmd,count,buf) \ + (SMBUS_BREAD(device_get_parent(bus), slave, cmd, count, buf)) + +#endif diff --git a/sys/dev/smbus/smbus.c b/sys/dev/smbus/smbus.c new file mode 100644 index 000000000000..f9f787d3a471 --- /dev/null +++ b/sys/dev/smbus/smbus.c @@ -0,0 +1,157 @@ +/*- + * Copyright (c) 1998 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. + * + * $Id: smbus.c,v 1.1.1.2 1998/08/13 15:16:58 son Exp $ + * + */ +#include +#include +#include +#include +#include + +#include +#include + +/* + * Autoconfiguration and support routines for the Philips serial I2C bus + */ + +#define DEVTOSMBUS(dev) ((struct smbus_device*)device_get_ivars(dev)) + +/* + * structure used to attach devices to the I2C bus + */ +struct smbus_device { + const char *smbd_name; /* device name */ + const u_char smbd_addr; /* address of the device */ + const char *smbd_desc; /* device descriptor */ +}; + +/* + * list of known devices + */ +struct smbus_device smbus_children[] = { + { "smb", 0, "General Call" }, + { NULL, 0 } +}; + +static devclass_t smbus_devclass; + +/* + * Device methods + */ +static int smbus_probe(device_t); +static int smbus_attach(device_t); +static void smbus_print_child(device_t, device_t); +static int smbus_read_ivar(device_t , device_t, int, u_long *); + +static device_method_t smbus_methods[] = { + /* device interface */ + DEVMETHOD(device_probe, smbus_probe), + DEVMETHOD(device_attach, smbus_attach), + DEVMETHOD(device_detach, bus_generic_detach), + DEVMETHOD(device_shutdown, bus_generic_shutdown), + + /* bus interface */ + DEVMETHOD(bus_print_child, smbus_print_child), + DEVMETHOD(bus_read_ivar, smbus_read_ivar), + DEVMETHOD(bus_write_ivar, bus_generic_write_ivar), + DEVMETHOD(bus_create_intr, bus_generic_create_intr), + DEVMETHOD(bus_connect_intr, bus_generic_connect_intr), + + { 0, 0 } +}; + +static driver_t smbus_driver = { + "smbus", + smbus_methods, + DRIVER_TYPE_MISC, + sizeof(struct smbus_softc), +}; + +/* + * At 'probe' time, we add all the devices which we know about to the + * bus. The generic attach routine will probe and attach them if they + * are alive. + */ +static int +smbus_probe(device_t dev) +{ + struct smbus_device *smbdev; + device_t child; + + for (smbdev = smbus_children; smbdev->smbd_name; smbdev++) { + + child = device_add_child(dev, smbdev->smbd_name, -1, smbdev); + device_set_desc(child, smbdev->smbd_desc); + } + + return (0); +} + +static int +smbus_attach(device_t dev) +{ + struct smbus_softc *sc = device_get_softc(dev); + device_t parent = device_get_parent(dev); + + printf("Probing for devices on the SMB bus:\n"); + bus_generic_attach(dev); + + return (0); +} + +void +smbus_generic_intr(device_t dev, u_char devaddr, char low, char high) +{ + return; +} + +static void +smbus_print_child(device_t bus, device_t dev) +{ + struct smbus_device* smbdev = DEVTOSMBUS(dev); + + printf(" on %s%d addr 0x%x", device_get_name(bus), + device_get_unit(bus), smbdev->smbd_addr); + + return; +} + +static int +smbus_read_ivar(device_t bus, device_t dev, int index, u_long* result) +{ + struct smbus_device* smbdev = DEVTOSMBUS(dev); + + switch (index) { + case SMBUS_IVAR_ADDR: + *result = smbdev->smbd_addr; + break; + } + return (ENOENT); +} + +DRIVER_MODULE(smbus, iicsmb, smbus_driver, smbus_devclass, 0, 0); diff --git a/sys/dev/smbus/smbus.h b/sys/dev/smbus/smbus.h new file mode 100644 index 000000000000..c89cde1856d9 --- /dev/null +++ b/sys/dev/smbus/smbus.h @@ -0,0 +1,41 @@ +/*- + * Copyright (c) 1998 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. + * + * $Id: smbus.h,v 1.1.1.1 1998/08/10 18:26:05 son Exp $ + * + */ +#ifndef __SMBUS_H +#define __SMBUS_H + +struct smbus_softc { + + device_t owner; /* smbus owner device structure */ +}; + +extern devclass_t smbus_devclass; + +extern void smbus_generic_intr(device_t dev, u_char devaddr, char low, char high); + +#endif diff --git a/sys/dev/smbus/smbus_if.m b/sys/dev/smbus/smbus_if.m new file mode 100644 index 000000000000..3c9ee5a0ecc1 --- /dev/null +++ b/sys/dev/smbus/smbus_if.m @@ -0,0 +1,140 @@ +# +# Copyright (c) 1998 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. +# +# $Id: smbus_if.m,v 1.1.1.2 1998/08/13 15:16:58 son Exp $ +# + +INTERFACE smbus + +# +# Interprete interrupt +# +METHOD void intr { + device_t dev; + u_char devaddr; + char low; + char high; + int error; +}; + +# +# Quick command +# +METHOD int quick { + device_t dev; + u_char slave; + int how; +}; + +# +# Send Byte command +# +METHOD int sendb { + device_t dev; + u_char slave; + char byte; +}; + +# +# Receive Byte command +# +METHOD int recvb { + device_t dev; + u_char slave; + char *byte; +}; + +# +# Write Byte command +# +METHOD int writeb { + device_t dev; + u_char slave; + char cmd; + char byte; +}; + +# +# Write Word command +# +METHOD int writew { + device_t dev; + u_char slave; + char cmd; + short word; +}; + +# +# Read Byte command +# +METHOD int readb { + device_t dev; + u_char slave; + char cmd; + char *byte; +}; + +# +# Read Word command +# +METHOD int readw { + device_t dev; + u_char slave; + char cmd; + short *word; +}; + +# +# Process Call command +# +METHOD int pcall { + device_t dev; + u_char slave; + char cmd; + short sdata; + short *rdata; +}; + +# +# Block Write command +# +METHODE int bwrite { + device_t dev; + u_char slave; + char cmd; + u_char count; + char *buf; +}; + +# +# Block Read command +# +METHODE int bread { + device_t dev; + u_char slave; + char cmd; + u_char count; + char *buf; +};