1998-09-03 20:52:54 +00:00
|
|
|
/*-
|
2002-03-23 15:49:15 +00:00
|
|
|
* Copyright (c) 1998, 2001 Nicolas Souchu
|
1998-09-03 20:52:54 +00:00
|
|
|
* 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.
|
|
|
|
*
|
1999-08-28 01:08:13 +00:00
|
|
|
* $FreeBSD$
|
1998-09-03 20:52:54 +00:00
|
|
|
*/
|
2004-05-17 18:55:45 +00:00
|
|
|
|
1998-09-03 20:52:54 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/kernel.h>
|
|
|
|
#include <sys/systm.h>
|
|
|
|
#include <sys/module.h>
|
|
|
|
#include <sys/bus.h>
|
|
|
|
#include <sys/conf.h>
|
|
|
|
#include <sys/uio.h>
|
1999-02-13 17:57:19 +00:00
|
|
|
#include <sys/fcntl.h>
|
1998-09-03 20:52:54 +00:00
|
|
|
|
|
|
|
#include <dev/smbus/smbconf.h>
|
|
|
|
#include <dev/smbus/smbus.h>
|
2002-09-19 03:25:46 +00:00
|
|
|
#include <dev/smbus/smb.h>
|
1998-09-03 20:52:54 +00:00
|
|
|
|
|
|
|
#include "smbus_if.h"
|
|
|
|
|
|
|
|
#define BUFSIZE 1024
|
|
|
|
|
|
|
|
struct smb_softc {
|
2008-06-06 18:45:32 +00:00
|
|
|
device_t sc_dev;
|
1998-09-03 20:52:54 +00:00
|
|
|
int sc_count; /* >0 if device opened */
|
2004-06-16 09:47:26 +00:00
|
|
|
struct cdev *sc_devnode;
|
2008-06-06 18:45:32 +00:00
|
|
|
struct mtx sc_lock;
|
1998-09-03 20:52:54 +00:00
|
|
|
};
|
|
|
|
|
Minor overhaul of SMBus support:
- Change smbus_callback() to pass a void * rather than caddr_t.
- Change smbus_bread() to pass a pointer to the count and have it be an
in/out parameter. The input is the size of the buffer (same as before),
but on return it will contain the actual amount of data read back from
the bus. Note that this value may be larger than the input value. It
is up to the caller to treat this as an error if desired.
- Change the SMB_BREAD ioctl to write out the updated struct smbcmd which
will contain the actual number of bytes read in the 'count' field. To
preserve the previous ABI, the old ioctl value is mapped to SMB_OLD_BREAD
which doesn't copy the updated smbcmd back out to userland. I doubt anyone
actually used the old BREAD anyway as it was rediculous to do a bulk-read
but not tell the using program how much data was actually read.
- Make the smbus driver and devclass public in the smbus module and
push all the DRIVER_MODULE()'s for attaching the smbus driver to
various foosmb drivers out into the foosmb modules. This makes all
the foosmb logic centralized and allows new foosmb modules to be
self-contained w/o having to hack smbus.c everytime a new smbus driver
is added.
- Add a new SMB_EINVAL error bit and use it in place of EINVAL to return
an error for bad arguments (such as invalid counts for bread and bwrite).
- Map SMB bus error bits to EIO in smbus_error().
- Make the smbus driver call bus_generic_probe() and require child drivers
such as smb(4) to create device_t's via identify routines. Previously,
smbus just created one anonymous device during attach, and if you had
multiple drivers that could attach it was just random chance as to which
driver got to probe for the sole device_t first.
- Add a mutex to the smbus(4) softc and use it in place of dummy splhigh()
to protect the 'owner' field and perform necessary synchronization for
smbus_request_bus() and smbus_release_bus().
- Change the bread() and bwrite() methods of alpm(4), amdpm(4), and
viapm(4) to only perform a single transaction and not try to use a
loop of multiple transactions for a large request. The framing and
commands to use for a large transaction depend on the upper-layer
protocol (such as SSIF for IPMI over SMBus) from what I can tell, and the
smb(4) driver never allowed bulk read/writes of more than 32-bytes
anyway. The other smb drivers only performed single transactions.
- Fix buffer overflows in the bread() methods of ichsmb(4), alpm(4),
amdpm(4), amdsmb(4), intpm(4), and nfsmb(4).
- Use SMB_xxx errors in viapm(4).
- Destroy ichsmb(4)'s mutex after bus_generic_detach() to avoid problems
from child devices making smb upcalls that would use the mutex during
their detach methods.
MFC after: 1 week
Reviewed by: jmg (mostly)
2006-09-11 20:52:41 +00:00
|
|
|
static void smb_identify(driver_t *driver, device_t parent);
|
1998-09-03 20:52:54 +00:00
|
|
|
static int smb_probe(device_t);
|
|
|
|
static int smb_attach(device_t);
|
2002-03-23 15:49:15 +00:00
|
|
|
static int smb_detach(device_t);
|
1998-09-03 20:52:54 +00:00
|
|
|
|
|
|
|
static devclass_t smb_devclass;
|
|
|
|
|
|
|
|
static device_method_t smb_methods[] = {
|
|
|
|
/* device interface */
|
Minor overhaul of SMBus support:
- Change smbus_callback() to pass a void * rather than caddr_t.
- Change smbus_bread() to pass a pointer to the count and have it be an
in/out parameter. The input is the size of the buffer (same as before),
but on return it will contain the actual amount of data read back from
the bus. Note that this value may be larger than the input value. It
is up to the caller to treat this as an error if desired.
- Change the SMB_BREAD ioctl to write out the updated struct smbcmd which
will contain the actual number of bytes read in the 'count' field. To
preserve the previous ABI, the old ioctl value is mapped to SMB_OLD_BREAD
which doesn't copy the updated smbcmd back out to userland. I doubt anyone
actually used the old BREAD anyway as it was rediculous to do a bulk-read
but not tell the using program how much data was actually read.
- Make the smbus driver and devclass public in the smbus module and
push all the DRIVER_MODULE()'s for attaching the smbus driver to
various foosmb drivers out into the foosmb modules. This makes all
the foosmb logic centralized and allows new foosmb modules to be
self-contained w/o having to hack smbus.c everytime a new smbus driver
is added.
- Add a new SMB_EINVAL error bit and use it in place of EINVAL to return
an error for bad arguments (such as invalid counts for bread and bwrite).
- Map SMB bus error bits to EIO in smbus_error().
- Make the smbus driver call bus_generic_probe() and require child drivers
such as smb(4) to create device_t's via identify routines. Previously,
smbus just created one anonymous device during attach, and if you had
multiple drivers that could attach it was just random chance as to which
driver got to probe for the sole device_t first.
- Add a mutex to the smbus(4) softc and use it in place of dummy splhigh()
to protect the 'owner' field and perform necessary synchronization for
smbus_request_bus() and smbus_release_bus().
- Change the bread() and bwrite() methods of alpm(4), amdpm(4), and
viapm(4) to only perform a single transaction and not try to use a
loop of multiple transactions for a large request. The framing and
commands to use for a large transaction depend on the upper-layer
protocol (such as SSIF for IPMI over SMBus) from what I can tell, and the
smb(4) driver never allowed bulk read/writes of more than 32-bytes
anyway. The other smb drivers only performed single transactions.
- Fix buffer overflows in the bread() methods of ichsmb(4), alpm(4),
amdpm(4), amdsmb(4), intpm(4), and nfsmb(4).
- Use SMB_xxx errors in viapm(4).
- Destroy ichsmb(4)'s mutex after bus_generic_detach() to avoid problems
from child devices making smb upcalls that would use the mutex during
their detach methods.
MFC after: 1 week
Reviewed by: jmg (mostly)
2006-09-11 20:52:41 +00:00
|
|
|
DEVMETHOD(device_identify, smb_identify),
|
1998-09-03 20:52:54 +00:00
|
|
|
DEVMETHOD(device_probe, smb_probe),
|
|
|
|
DEVMETHOD(device_attach, smb_attach),
|
2002-03-23 15:49:15 +00:00
|
|
|
DEVMETHOD(device_detach, smb_detach),
|
1998-09-03 20:52:54 +00:00
|
|
|
|
|
|
|
/* smbus interface */
|
|
|
|
DEVMETHOD(smbus_intr, smbus_generic_intr),
|
|
|
|
|
|
|
|
{ 0, 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static driver_t smb_driver = {
|
|
|
|
"smb",
|
|
|
|
smb_methods,
|
|
|
|
sizeof(struct smb_softc),
|
|
|
|
};
|
|
|
|
|
|
|
|
static d_open_t smbopen;
|
|
|
|
static d_close_t smbclose;
|
|
|
|
static d_ioctl_t smbioctl;
|
|
|
|
|
1999-05-30 16:53:49 +00:00
|
|
|
static struct cdevsw smb_cdevsw = {
|
2004-02-21 21:10:55 +00:00
|
|
|
.d_version = D_VERSION,
|
2008-06-06 18:45:32 +00:00
|
|
|
.d_flags = D_TRACKCLOSE,
|
2003-03-03 12:15:54 +00:00
|
|
|
.d_open = smbopen,
|
|
|
|
.d_close = smbclose,
|
|
|
|
.d_ioctl = smbioctl,
|
|
|
|
.d_name = "smb",
|
1999-05-30 16:53:49 +00:00
|
|
|
};
|
1998-09-03 20:52:54 +00:00
|
|
|
|
Minor overhaul of SMBus support:
- Change smbus_callback() to pass a void * rather than caddr_t.
- Change smbus_bread() to pass a pointer to the count and have it be an
in/out parameter. The input is the size of the buffer (same as before),
but on return it will contain the actual amount of data read back from
the bus. Note that this value may be larger than the input value. It
is up to the caller to treat this as an error if desired.
- Change the SMB_BREAD ioctl to write out the updated struct smbcmd which
will contain the actual number of bytes read in the 'count' field. To
preserve the previous ABI, the old ioctl value is mapped to SMB_OLD_BREAD
which doesn't copy the updated smbcmd back out to userland. I doubt anyone
actually used the old BREAD anyway as it was rediculous to do a bulk-read
but not tell the using program how much data was actually read.
- Make the smbus driver and devclass public in the smbus module and
push all the DRIVER_MODULE()'s for attaching the smbus driver to
various foosmb drivers out into the foosmb modules. This makes all
the foosmb logic centralized and allows new foosmb modules to be
self-contained w/o having to hack smbus.c everytime a new smbus driver
is added.
- Add a new SMB_EINVAL error bit and use it in place of EINVAL to return
an error for bad arguments (such as invalid counts for bread and bwrite).
- Map SMB bus error bits to EIO in smbus_error().
- Make the smbus driver call bus_generic_probe() and require child drivers
such as smb(4) to create device_t's via identify routines. Previously,
smbus just created one anonymous device during attach, and if you had
multiple drivers that could attach it was just random chance as to which
driver got to probe for the sole device_t first.
- Add a mutex to the smbus(4) softc and use it in place of dummy splhigh()
to protect the 'owner' field and perform necessary synchronization for
smbus_request_bus() and smbus_release_bus().
- Change the bread() and bwrite() methods of alpm(4), amdpm(4), and
viapm(4) to only perform a single transaction and not try to use a
loop of multiple transactions for a large request. The framing and
commands to use for a large transaction depend on the upper-layer
protocol (such as SSIF for IPMI over SMBus) from what I can tell, and the
smb(4) driver never allowed bulk read/writes of more than 32-bytes
anyway. The other smb drivers only performed single transactions.
- Fix buffer overflows in the bread() methods of ichsmb(4), alpm(4),
amdpm(4), amdsmb(4), intpm(4), and nfsmb(4).
- Use SMB_xxx errors in viapm(4).
- Destroy ichsmb(4)'s mutex after bus_generic_detach() to avoid problems
from child devices making smb upcalls that would use the mutex during
their detach methods.
MFC after: 1 week
Reviewed by: jmg (mostly)
2006-09-11 20:52:41 +00:00
|
|
|
static void
|
|
|
|
smb_identify(driver_t *driver, device_t parent)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (device_find_child(parent, "smb", -1) == NULL)
|
|
|
|
BUS_ADD_CHILD(parent, 0, "smb", -1);
|
|
|
|
}
|
|
|
|
|
1998-09-03 20:52:54 +00:00
|
|
|
static int
|
|
|
|
smb_probe(device_t dev)
|
|
|
|
{
|
2015-04-25 16:15:01 +00:00
|
|
|
if (smbus_get_addr(dev) != -1)
|
|
|
|
return (ENXIO);
|
1998-09-03 20:52:54 +00:00
|
|
|
|
2015-04-25 16:15:01 +00:00
|
|
|
device_set_desc(dev, "SMBus generic I/O");
|
|
|
|
return (BUS_PROBE_NOWILDCARD);
|
1998-09-03 20:52:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
smb_attach(device_t dev)
|
|
|
|
{
|
2008-06-06 18:45:32 +00:00
|
|
|
struct smb_softc *sc = device_get_softc(dev);
|
2015-04-25 16:15:01 +00:00
|
|
|
int unit;
|
|
|
|
|
|
|
|
unit = device_get_unit(dev);
|
2008-06-06 18:45:32 +00:00
|
|
|
sc->sc_dev = dev;
|
2015-04-25 16:15:01 +00:00
|
|
|
|
|
|
|
sc->sc_devnode = make_dev(&smb_cdevsw, unit, UID_ROOT, GID_WHEEL,
|
|
|
|
0600, "smb%d", unit);
|
2008-06-06 18:45:32 +00:00
|
|
|
sc->sc_devnode->si_drv1 = sc;
|
|
|
|
mtx_init(&sc->sc_lock, device_get_nameunit(dev), NULL, MTX_DEF);
|
2002-03-23 15:49:15 +00:00
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
smb_detach(device_t dev)
|
|
|
|
{
|
|
|
|
struct smb_softc *sc = (struct smb_softc *)device_get_softc(dev);
|
|
|
|
|
|
|
|
if (sc->sc_devnode)
|
|
|
|
destroy_dev(sc->sc_devnode);
|
2008-06-06 18:45:32 +00:00
|
|
|
mtx_destroy(&sc->sc_lock);
|
2002-03-23 15:49:15 +00:00
|
|
|
|
1998-09-03 20:52:54 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2008-06-06 18:45:32 +00:00
|
|
|
smbopen(struct cdev *dev, int flags, int fmt, struct thread *td)
|
1998-09-03 20:52:54 +00:00
|
|
|
{
|
2008-06-06 18:45:32 +00:00
|
|
|
struct smb_softc *sc = dev->si_drv1;
|
1998-09-03 20:52:54 +00:00
|
|
|
|
2008-06-06 18:45:32 +00:00
|
|
|
mtx_lock(&sc->sc_lock);
|
|
|
|
if (sc->sc_count != 0) {
|
|
|
|
mtx_unlock(&sc->sc_lock);
|
1998-09-03 20:52:54 +00:00
|
|
|
return (EBUSY);
|
2008-06-06 18:45:32 +00:00
|
|
|
}
|
1998-09-03 20:52:54 +00:00
|
|
|
|
|
|
|
sc->sc_count++;
|
2008-06-06 18:45:32 +00:00
|
|
|
mtx_unlock(&sc->sc_lock);
|
1998-09-03 20:52:54 +00:00
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2004-06-16 09:47:26 +00:00
|
|
|
smbclose(struct cdev *dev, int flags, int fmt, struct thread *td)
|
1998-09-03 20:52:54 +00:00
|
|
|
{
|
2008-06-06 18:45:32 +00:00
|
|
|
struct smb_softc *sc = dev->si_drv1;
|
1998-09-03 20:52:54 +00:00
|
|
|
|
2008-06-06 18:45:32 +00:00
|
|
|
mtx_lock(&sc->sc_lock);
|
|
|
|
KASSERT(sc->sc_count == 1, ("device not busy"));
|
1998-09-03 20:52:54 +00:00
|
|
|
sc->sc_count--;
|
2008-06-06 18:45:32 +00:00
|
|
|
mtx_unlock(&sc->sc_lock);
|
1998-09-03 20:52:54 +00:00
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2004-06-16 09:47:26 +00:00
|
|
|
smbioctl(struct cdev *dev, u_long cmd, caddr_t data, int flags, struct thread *td)
|
1998-09-03 20:52:54 +00:00
|
|
|
{
|
2004-05-16 21:18:45 +00:00
|
|
|
char buf[SMB_MAXBLOCKSIZE];
|
2004-05-17 18:55:45 +00:00
|
|
|
device_t parent;
|
1998-09-03 20:52:54 +00:00
|
|
|
struct smbcmd *s = (struct smbcmd *)data;
|
2008-06-06 18:45:32 +00:00
|
|
|
struct smb_softc *sc = dev->si_drv1;
|
|
|
|
device_t smbdev = sc->sc_dev;
|
2004-05-17 18:55:45 +00:00
|
|
|
int error;
|
2015-04-25 16:15:01 +00:00
|
|
|
int unit;
|
|
|
|
u_char bcount;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If a specific slave device is being used, override any passed-in
|
|
|
|
* slave.
|
|
|
|
*/
|
|
|
|
unit = dev2unit(dev);
|
|
|
|
if (unit & 0x0400)
|
|
|
|
s->slave = unit & 0x03ff;
|
1998-09-03 20:52:54 +00:00
|
|
|
|
2004-05-17 18:55:45 +00:00
|
|
|
parent = device_get_parent(smbdev);
|
|
|
|
|
2009-02-03 16:14:37 +00:00
|
|
|
/* Make sure that LSB bit is cleared. */
|
|
|
|
if (s->slave & 0x1)
|
|
|
|
return (EINVAL);
|
|
|
|
|
2004-05-17 18:55:45 +00:00
|
|
|
/* Allocate the bus. */
|
1999-02-13 17:57:19 +00:00
|
|
|
if ((error = smbus_request_bus(parent, smbdev,
|
|
|
|
(flags & O_NONBLOCK) ? SMB_DONTWAIT : (SMB_WAIT | SMB_INTR))))
|
|
|
|
return (error);
|
|
|
|
|
1998-09-03 20:52:54 +00:00
|
|
|
switch (cmd) {
|
|
|
|
case SMB_QUICK_WRITE:
|
1999-02-14 14:36:45 +00:00
|
|
|
error = smbus_error(smbus_quick(parent, s->slave, SMB_QWRITE));
|
1999-02-13 17:57:19 +00:00
|
|
|
break;
|
1998-09-03 20:52:54 +00:00
|
|
|
|
|
|
|
case SMB_QUICK_READ:
|
1999-02-14 14:36:45 +00:00
|
|
|
error = smbus_error(smbus_quick(parent, s->slave, SMB_QREAD));
|
1999-02-13 17:57:19 +00:00
|
|
|
break;
|
1998-09-03 20:52:54 +00:00
|
|
|
|
|
|
|
case SMB_SENDB:
|
1999-02-14 14:36:45 +00:00
|
|
|
error = smbus_error(smbus_sendb(parent, s->slave, s->cmd));
|
1998-09-03 20:52:54 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SMB_RECVB:
|
1999-02-14 14:36:45 +00:00
|
|
|
error = smbus_error(smbus_recvb(parent, s->slave, &s->cmd));
|
1998-09-03 20:52:54 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SMB_WRITEB:
|
1999-02-14 14:36:45 +00:00
|
|
|
error = smbus_error(smbus_writeb(parent, s->slave, s->cmd,
|
2015-04-25 16:15:01 +00:00
|
|
|
s->wdata.byte));
|
1998-09-03 20:52:54 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SMB_WRITEW:
|
1999-02-14 14:36:45 +00:00
|
|
|
error = smbus_error(smbus_writew(parent, s->slave,
|
2015-04-25 16:15:01 +00:00
|
|
|
s->cmd, s->wdata.word));
|
1998-09-03 20:52:54 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SMB_READB:
|
2015-04-25 16:15:01 +00:00
|
|
|
error = smbus_error(smbus_readb(parent, s->slave, s->cmd,
|
|
|
|
&s->rdata.byte));
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
if (s->rbuf && s->rcount >= 1) {
|
|
|
|
error = copyout(&s->rdata.byte, s->rbuf, 1);
|
|
|
|
s->rcount = 1;
|
2004-05-16 21:18:45 +00:00
|
|
|
}
|
1998-09-03 20:52:54 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SMB_READW:
|
2015-04-25 16:15:01 +00:00
|
|
|
error = smbus_error(smbus_readw(parent, s->slave, s->cmd,
|
|
|
|
&s->rdata.word));
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
if (s->rbuf && s->rcount >= 2) {
|
|
|
|
buf[0] = (u_char)s->rdata.word;
|
|
|
|
buf[1] = (u_char)(s->rdata.word >> 8);
|
|
|
|
error = copyout(buf, s->rbuf, 2);
|
|
|
|
s->rcount = 2;
|
2004-05-16 21:18:45 +00:00
|
|
|
}
|
1998-09-03 20:52:54 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SMB_PCALL:
|
2015-04-25 16:15:01 +00:00
|
|
|
error = smbus_error(smbus_pcall(parent, s->slave, s->cmd,
|
|
|
|
s->wdata.word, &s->rdata.word));
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
if (s->rbuf && s->rcount >= 2) {
|
|
|
|
buf[0] = (u_char)s->rdata.word;
|
|
|
|
buf[1] = (u_char)(s->rdata.word >> 8);
|
|
|
|
error = copyout(buf, s->rbuf, 2);
|
|
|
|
s->rcount = 2;
|
2004-05-16 21:18:45 +00:00
|
|
|
}
|
2015-04-25 16:15:01 +00:00
|
|
|
|
1998-09-03 20:52:54 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SMB_BWRITE:
|
2015-04-25 16:15:01 +00:00
|
|
|
if (s->wcount < 0) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
2004-05-16 21:18:45 +00:00
|
|
|
}
|
2015-04-25 16:15:01 +00:00
|
|
|
if (s->wcount > SMB_MAXBLOCKSIZE)
|
|
|
|
s->wcount = SMB_MAXBLOCKSIZE;
|
|
|
|
if (s->wcount)
|
|
|
|
error = copyin(s->wbuf, buf, s->wcount);
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
error = smbus_error(smbus_bwrite(parent, s->slave, s->cmd,
|
|
|
|
s->wcount, buf));
|
1998-09-03 20:52:54 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SMB_BREAD:
|
2015-04-25 16:15:01 +00:00
|
|
|
if (s->rcount < 0) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (s->rcount > SMB_MAXBLOCKSIZE)
|
|
|
|
s->rcount = SMB_MAXBLOCKSIZE;
|
|
|
|
error = smbus_error(smbus_bread(parent, s->slave, s->cmd,
|
|
|
|
&bcount, buf));
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
if (s->rcount > bcount)
|
|
|
|
s->rcount = bcount;
|
|
|
|
error = copyout(buf, s->rbuf, s->rcount);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SMB_TRANS:
|
|
|
|
if (s->rcount < 0 || s->wcount < 0) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
2004-05-16 21:18:45 +00:00
|
|
|
}
|
2015-04-25 16:15:01 +00:00
|
|
|
if (s->rcount > SMB_MAXBLOCKSIZE)
|
|
|
|
s->rcount = SMB_MAXBLOCKSIZE;
|
|
|
|
if (s->wcount > SMB_MAXBLOCKSIZE)
|
|
|
|
s->wcount = SMB_MAXBLOCKSIZE;
|
|
|
|
if (s->wcount)
|
|
|
|
error = copyin(s->wbuf, buf, s->wcount);
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
error = smbus_error(smbus_trans(parent, s->slave, s->cmd,
|
|
|
|
s->op, buf, s->wcount, buf, s->rcount, &s->rcount));
|
|
|
|
if (error == 0)
|
|
|
|
error = copyout(buf, s->rbuf, s->rcount);
|
1998-09-03 20:52:54 +00:00
|
|
|
break;
|
|
|
|
default:
|
2004-05-16 21:18:45 +00:00
|
|
|
error = ENOTTY;
|
1998-09-03 20:52:54 +00:00
|
|
|
}
|
|
|
|
|
1999-02-13 17:57:19 +00:00
|
|
|
smbus_release_bus(parent, smbdev);
|
|
|
|
|
1998-09-03 20:52:54 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1999-11-08 07:37:15 +00:00
|
|
|
DRIVER_MODULE(smb, smbus, smb_driver, smb_devclass, 0, 0);
|
2002-03-23 15:49:15 +00:00
|
|
|
MODULE_DEPEND(smb, smbus, SMBUS_MINVER, SMBUS_PREFVER, SMBUS_MAXVER);
|
|
|
|
MODULE_VERSION(smb, 1);
|