2020-08-06 13:41:42 +00:00
|
|
|
/*-
|
|
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
|
|
*
|
|
|
|
* Copyright (c) Andriy Gapon
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Hardware information links:
|
|
|
|
* - CP2112 Datasheet
|
|
|
|
* https://www.silabs.com/documents/public/data-sheets/cp2112-datasheet.pdf
|
|
|
|
* - AN495: CP2112 Interface Specification
|
|
|
|
* https://www.silabs.com/documents/public/application-notes/an495-cp2112-interface-specification.pdf
|
|
|
|
* - CP2112 Errata
|
|
|
|
* https://www.silabs.com/documents/public/errata/cp2112-errata.pdf
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
|
|
|
#include <sys/condvar.h>
|
|
|
|
#include <sys/bus.h>
|
|
|
|
#include <sys/gpio.h>
|
|
|
|
#include <sys/kernel.h>
|
|
|
|
#include <sys/lock.h>
|
|
|
|
#include <sys/module.h>
|
|
|
|
#include <sys/mutex.h>
|
|
|
|
#include <sys/sdt.h>
|
|
|
|
#include <sys/sx.h>
|
|
|
|
|
|
|
|
#include <dev/gpio/gpiobusvar.h>
|
|
|
|
|
|
|
|
#include <dev/iicbus/iiconf.h>
|
|
|
|
#include <dev/iicbus/iicbus.h>
|
|
|
|
#include "iicbus_if.h"
|
|
|
|
|
|
|
|
#include <dev/usb/usb.h>
|
|
|
|
#include <dev/usb/usbdi.h>
|
|
|
|
#include <dev/usb/usbdi_util.h>
|
|
|
|
#include <dev/usb/usbhid.h>
|
|
|
|
#include "usbdevs.h"
|
|
|
|
|
|
|
|
#define USB_DEBUG_VAR usb_debug
|
|
|
|
#include <dev/usb/usb_debug.h>
|
|
|
|
|
2020-08-12 09:07:07 +00:00
|
|
|
#define SIZEOF_FIELD(_s, _f) sizeof(((struct _s *)NULL)->_f)
|
|
|
|
|
2020-08-06 13:41:42 +00:00
|
|
|
#define CP2112GPIO_LOCK(sc) sx_xlock(&sc->gpio_lock)
|
|
|
|
#define CP2112GPIO_UNLOCK(sc) sx_xunlock(&sc->gpio_lock)
|
|
|
|
#define CP2112GPIO_LOCKED(sc) sx_assert(&sc->gpio_lock, SX_XLOCKED)
|
|
|
|
|
|
|
|
#define CP2112_PART_NUM 0x0c
|
|
|
|
#define CP2112_GPIO_COUNT 8
|
|
|
|
#define CP2112_REPORT_SIZE 64
|
|
|
|
|
|
|
|
#define CP2112_REQ_RESET 0x1
|
|
|
|
#define CP2112_REQ_GPIO_CFG 0x2
|
|
|
|
#define CP2112_REQ_GPIO_GET 0x3
|
|
|
|
#define CP2112_REQ_GPIO_SET 0x4
|
|
|
|
#define CP2112_REQ_VERSION 0x5
|
|
|
|
#define CP2112_REQ_SMB_CFG 0x6
|
|
|
|
|
|
|
|
#define CP2112_REQ_SMB_READ 0x10
|
|
|
|
#define CP2112_REQ_SMB_WRITE_READ 0x11
|
|
|
|
#define CP2112_REQ_SMB_READ_FORCE_SEND 0x12
|
|
|
|
#define CP2112_REQ_SMB_READ_RESPONSE 0x13
|
|
|
|
#define CP2112_REQ_SMB_WRITE 0x14
|
|
|
|
#define CP2112_REQ_SMB_XFER_STATUS_REQ 0x15
|
|
|
|
#define CP2112_REQ_SMB_XFER_STATUS_RESP 0x16
|
|
|
|
#define CP2112_REQ_SMB_CANCEL 0x17
|
|
|
|
|
|
|
|
#define CP2112_REQ_LOCK 0x20
|
|
|
|
#define CP2112_REQ_USB_CFG 0x21
|
|
|
|
|
2020-08-12 09:07:07 +00:00
|
|
|
#define CP2112_IIC_MAX_READ_LEN 512
|
2020-08-06 13:41:42 +00:00
|
|
|
#define CP2112_IIC_REPSTART_VER 2 /* Erratum CP2112_E10. */
|
|
|
|
|
2020-08-12 09:07:07 +00:00
|
|
|
#define CP2112_GPIO_SPEC_CLK7 1 /* Pin 7 is clock output. */
|
|
|
|
#define CP2112_GPIO_SPEC_TX0 2 /* Pin 0 pulses on USB TX. */
|
|
|
|
#define CP2112_GPIO_SPEC_RX1 4 /* Pin 1 pulses on USB RX. */
|
|
|
|
|
2020-08-06 13:41:42 +00:00
|
|
|
#define CP2112_IIC_STATUS0_IDLE 0
|
|
|
|
#define CP2112_IIC_STATUS0_BUSY 1
|
|
|
|
#define CP2112_IIC_STATUS0_CMP 2
|
|
|
|
#define CP2112_IIC_STATUS0_ERROR 3
|
|
|
|
|
|
|
|
#define CP2112_IIC_STATUS1_TIMEOUT_NACK 0
|
|
|
|
#define CP2112_IIC_STATUS1_TIMEOUT_BUS 1
|
|
|
|
#define CP2112_IIC_STATUS1_ARB_LOST 2
|
|
|
|
|
2020-08-12 09:07:07 +00:00
|
|
|
/* CP2112_REQ_VERSION */
|
|
|
|
struct version_request {
|
|
|
|
uint8_t id;
|
|
|
|
uint8_t part_num;
|
|
|
|
uint8_t version;
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
/* CP2112_REQ_GPIO_GET */
|
|
|
|
struct gpio_get_req {
|
|
|
|
uint8_t id;
|
|
|
|
uint8_t state;
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
/* CP2112_REQ_GPIO_SET */
|
|
|
|
struct gpio_set_req {
|
|
|
|
uint8_t id;
|
|
|
|
uint8_t state;
|
|
|
|
uint8_t mask;
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
/* CP2112_REQ_GPIO_CFG */
|
|
|
|
struct gpio_config_req {
|
|
|
|
uint8_t id;
|
|
|
|
uint8_t output;
|
|
|
|
uint8_t pushpull;
|
|
|
|
uint8_t special;
|
|
|
|
uint8_t divider;
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
/* CP2112_REQ_SMB_XFER_STATUS_REQ */
|
|
|
|
struct i2c_xfer_status_req {
|
|
|
|
uint8_t id;
|
|
|
|
uint8_t request;
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
/* CP2112_REQ_SMB_XFER_STATUS_RESP */
|
|
|
|
struct i2c_xfer_status_resp {
|
|
|
|
uint8_t id;
|
|
|
|
uint8_t status0;
|
|
|
|
uint8_t status1;
|
|
|
|
uint16_t status2;
|
|
|
|
uint16_t status3;
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
/* CP2112_REQ_SMB_READ_FORCE_SEND */
|
|
|
|
struct i2c_data_read_force_send_req {
|
|
|
|
uint8_t id;
|
|
|
|
uint16_t len;
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
/* CP2112_REQ_SMB_READ_RESPONSE */
|
|
|
|
struct i2c_data_read_resp {
|
|
|
|
uint8_t id;
|
|
|
|
uint8_t status;
|
|
|
|
uint8_t len;
|
|
|
|
uint8_t data[61];
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
/* CP2112_REQ_SMB_READ */
|
|
|
|
struct i2c_write_read_req {
|
|
|
|
uint8_t id;
|
|
|
|
uint8_t slave;
|
|
|
|
uint16_t rlen;
|
|
|
|
uint8_t wlen;
|
|
|
|
uint8_t wdata[16];
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
/* CP2112_REQ_SMB_WRITE */
|
|
|
|
struct i2c_read_req {
|
|
|
|
uint8_t id;
|
|
|
|
uint8_t slave;
|
|
|
|
uint16_t len;
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
/* CP2112_REQ_SMB_WRITE_READ */
|
|
|
|
struct i2c_write_req {
|
|
|
|
uint8_t id;
|
|
|
|
uint8_t slave;
|
|
|
|
uint8_t len;
|
|
|
|
uint8_t data[61];
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
/* CP2112_REQ_SMB_CFG */
|
|
|
|
struct i2c_cfg_req {
|
|
|
|
uint8_t id;
|
|
|
|
uint32_t speed; /* Hz */
|
|
|
|
uint8_t slave_addr; /* ACK only */
|
|
|
|
uint8_t auto_send_read; /* boolean */
|
|
|
|
uint16_t write_timeout; /* 0-1000 ms, 0 ~ no timeout */
|
|
|
|
uint16_t read_timeout; /* 0-1000 ms, 0 ~ no timeout */
|
|
|
|
uint8_t scl_low_timeout;/* boolean */
|
|
|
|
uint16_t retry_count; /* 1-1000, 0 ~ forever */
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
enum cp2112_out_mode {
|
|
|
|
OUT_OD,
|
|
|
|
OUT_PP,
|
|
|
|
OUT_KEEP
|
|
|
|
};
|
|
|
|
|
|
|
|
enum {
|
|
|
|
CP2112_INTR_OUT = 0,
|
|
|
|
CP2112_INTR_IN,
|
|
|
|
CP2112_N_TRANSFER,
|
|
|
|
};
|
2020-08-06 13:41:42 +00:00
|
|
|
|
|
|
|
struct cp2112_softc {
|
|
|
|
device_t sc_gpio_dev;
|
|
|
|
device_t sc_iic_dev;
|
|
|
|
struct usb_device *sc_udev;
|
|
|
|
uint8_t sc_iface_index;
|
|
|
|
uint8_t sc_version;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct cp2112gpio_softc {
|
|
|
|
struct sx gpio_lock;
|
|
|
|
device_t busdev;
|
|
|
|
int gpio_caps;
|
|
|
|
struct gpio_pin pins[CP2112_GPIO_COUNT];
|
|
|
|
};
|
|
|
|
|
2020-08-12 09:07:07 +00:00
|
|
|
struct cp2112iic_softc {
|
|
|
|
device_t dev;
|
|
|
|
device_t iicbus_dev;
|
|
|
|
struct usb_xfer *xfers[CP2112_N_TRANSFER];
|
|
|
|
u_char own_addr;
|
|
|
|
struct {
|
|
|
|
struct mtx lock;
|
|
|
|
struct cv cv;
|
|
|
|
struct {
|
|
|
|
uint8_t *data;
|
|
|
|
int len;
|
|
|
|
int done;
|
|
|
|
int error;
|
|
|
|
} in;
|
|
|
|
struct {
|
|
|
|
const uint8_t *data;
|
|
|
|
int len;
|
|
|
|
int done;
|
|
|
|
int error;
|
|
|
|
} out;
|
|
|
|
} io;
|
|
|
|
};
|
|
|
|
|
2020-08-06 13:41:42 +00:00
|
|
|
static int cp2112_detach(device_t dev);
|
|
|
|
static int cp2112gpio_detach(device_t dev);
|
|
|
|
static int cp2112iic_detach(device_t dev);
|
|
|
|
|
2020-08-12 09:07:07 +00:00
|
|
|
static const STRUCT_USB_HOST_ID cp2112_devs[] = {
|
|
|
|
{ USB_VP(USB_VENDOR_SILABS, USB_PRODUCT_SILABS_CP2112) },
|
|
|
|
{ USB_VP(0x1009, USB_PRODUCT_SILABS_CP2112) }, /* XXX */
|
|
|
|
};
|
|
|
|
|
2020-08-06 13:41:42 +00:00
|
|
|
static int
|
|
|
|
cp2112_get_report(device_t dev, uint8_t id, void *data, uint16_t len)
|
|
|
|
{
|
|
|
|
struct cp2112_softc *sc;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
err = usbd_req_get_report(sc->sc_udev, NULL, data,
|
|
|
|
len, sc->sc_iface_index, UHID_FEATURE_REPORT, id);
|
|
|
|
return (err);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cp2112_set_report(device_t dev, uint8_t id, void *data, uint16_t len)
|
|
|
|
{
|
|
|
|
struct cp2112_softc *sc;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
2020-08-12 09:07:07 +00:00
|
|
|
*(uint8_t *)data = id;
|
2020-08-06 13:41:42 +00:00
|
|
|
err = usbd_req_set_report(sc->sc_udev, NULL, data,
|
|
|
|
len, sc->sc_iface_index, UHID_FEATURE_REPORT, id);
|
|
|
|
return (err);
|
|
|
|
}
|
|
|
|
|
2020-08-12 09:07:07 +00:00
|
|
|
static int
|
|
|
|
cp2112_probe(device_t dev)
|
|
|
|
{
|
|
|
|
struct usb_attach_arg *uaa;
|
|
|
|
|
|
|
|
uaa = device_get_ivars(dev);
|
|
|
|
if (uaa->usb_mode != USB_MODE_HOST)
|
|
|
|
return (ENXIO);
|
|
|
|
if (uaa->info.bInterfaceClass != UICLASS_HID)
|
|
|
|
return (ENXIO);
|
|
|
|
|
|
|
|
if (usbd_lookup_id_by_uaa(cp2112_devs, sizeof(cp2112_devs), uaa) == 0)
|
|
|
|
return (BUS_PROBE_DEFAULT);
|
|
|
|
return (ENXIO);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cp2112_attach(device_t dev)
|
|
|
|
{
|
|
|
|
struct version_request vdata;
|
|
|
|
struct usb_attach_arg *uaa;
|
|
|
|
struct cp2112_softc *sc;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
uaa = device_get_ivars(dev);
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
|
|
|
|
device_set_usb_desc(dev);
|
|
|
|
|
|
|
|
sc->sc_udev = uaa->device;
|
|
|
|
sc->sc_iface_index = uaa->info.bIfaceIndex;
|
|
|
|
|
|
|
|
err = cp2112_get_report(dev, CP2112_REQ_VERSION, &vdata, sizeof(vdata));
|
|
|
|
if (err != 0)
|
|
|
|
goto detach;
|
|
|
|
device_printf(dev, "part number 0x%02x, version 0x%02x\n",
|
|
|
|
vdata.part_num, vdata.version);
|
|
|
|
if (vdata.part_num != CP2112_PART_NUM) {
|
|
|
|
device_printf(dev, "unsupported part number\n");
|
|
|
|
goto detach;
|
|
|
|
}
|
|
|
|
sc->sc_version = vdata.version;
|
|
|
|
sc->sc_gpio_dev = device_add_child(dev, "gpio", -1);
|
|
|
|
if (sc->sc_gpio_dev != NULL) {
|
|
|
|
err = device_probe_and_attach(sc->sc_gpio_dev);
|
|
|
|
if (err != 0) {
|
|
|
|
device_printf(dev, "failed to attach gpio child\n");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
device_printf(dev, "failed to create gpio child\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
sc->sc_iic_dev = device_add_child(dev, "iichb", -1);
|
|
|
|
if (sc->sc_iic_dev != NULL) {
|
|
|
|
err = device_probe_and_attach(sc->sc_iic_dev);
|
|
|
|
if (err != 0) {
|
|
|
|
device_printf(dev, "failed to attach iic child\n");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
device_printf(dev, "failed to create iic child\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
|
|
|
|
detach:
|
|
|
|
cp2112_detach(dev);
|
|
|
|
return (ENXIO);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cp2112_detach(device_t dev)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = bus_generic_detach(dev);
|
|
|
|
if (err != 0)
|
|
|
|
return (err);
|
|
|
|
device_delete_children(dev);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2020-08-06 13:41:42 +00:00
|
|
|
static int
|
|
|
|
cp2112_gpio_read_pin(device_t dev, uint32_t pin_num, bool *on)
|
|
|
|
{
|
2020-08-12 09:07:07 +00:00
|
|
|
struct gpio_get_req data;
|
2020-08-06 13:41:42 +00:00
|
|
|
struct cp2112gpio_softc *sc;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
CP2112GPIO_LOCKED(sc);
|
|
|
|
|
|
|
|
err = cp2112_get_report(device_get_parent(dev),
|
|
|
|
CP2112_REQ_GPIO_GET, &data, sizeof(data));
|
|
|
|
if (err != 0)
|
|
|
|
return (err);
|
|
|
|
*on = (data.state & ((uint8_t)1 << pin_num)) != 0;
|
|
|
|
return (0);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cp2112_gpio_write_pin(device_t dev, uint32_t pin_num, bool on)
|
|
|
|
{
|
2020-08-12 09:07:07 +00:00
|
|
|
struct gpio_set_req data;
|
2020-08-06 13:41:42 +00:00
|
|
|
struct cp2112gpio_softc *sc;
|
|
|
|
int err;
|
|
|
|
bool actual;
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
CP2112GPIO_LOCKED(sc);
|
|
|
|
|
|
|
|
data.state = (uint8_t)on << pin_num;
|
|
|
|
data.mask = (uint8_t)1 << pin_num;
|
|
|
|
err = cp2112_set_report(device_get_parent(dev),
|
|
|
|
CP2112_REQ_GPIO_SET, &data, sizeof(data));
|
|
|
|
if (err != 0)
|
|
|
|
return (err);
|
|
|
|
err = cp2112_gpio_read_pin(dev, pin_num, &actual);
|
|
|
|
if (err != 0)
|
|
|
|
return (err);
|
|
|
|
if (actual != on)
|
|
|
|
return (EIO);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cp2112_gpio_configure_write_pin(device_t dev, uint32_t pin_num,
|
2020-08-12 09:07:07 +00:00
|
|
|
bool output, enum cp2112_out_mode *mode)
|
2020-08-06 13:41:42 +00:00
|
|
|
{
|
2020-08-12 09:07:07 +00:00
|
|
|
struct gpio_config_req data;
|
2020-08-06 13:41:42 +00:00
|
|
|
struct cp2112gpio_softc *sc;
|
|
|
|
int err;
|
|
|
|
uint8_t mask;
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
CP2112GPIO_LOCKED(sc);
|
|
|
|
|
|
|
|
err = cp2112_get_report(device_get_parent(dev),
|
|
|
|
CP2112_REQ_GPIO_CFG, &data, sizeof(data));
|
|
|
|
if (err != 0)
|
|
|
|
return (err);
|
2020-08-12 09:07:07 +00:00
|
|
|
|
|
|
|
mask = (uint8_t)1 << pin_num;
|
2020-08-06 13:41:42 +00:00
|
|
|
if (output) {
|
|
|
|
data.output |= mask;
|
2020-08-12 09:07:07 +00:00
|
|
|
switch (*mode) {
|
|
|
|
case OUT_PP:
|
2020-08-06 13:41:42 +00:00
|
|
|
data.pushpull |= mask;
|
2020-08-12 09:07:07 +00:00
|
|
|
break;
|
|
|
|
case OUT_OD:
|
2020-08-06 13:41:42 +00:00
|
|
|
data.pushpull &= ~mask;
|
2020-08-12 09:07:07 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2020-08-06 13:41:42 +00:00
|
|
|
} else {
|
|
|
|
data.output &= ~mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = cp2112_set_report(device_get_parent(dev),
|
|
|
|
CP2112_REQ_GPIO_CFG, &data, sizeof(data));
|
|
|
|
if (err != 0)
|
|
|
|
return (err);
|
|
|
|
|
|
|
|
/* Read back and verify. */
|
|
|
|
err = cp2112_get_report(device_get_parent(dev),
|
|
|
|
CP2112_REQ_GPIO_CFG, &data, sizeof(data));
|
|
|
|
if (err != 0)
|
|
|
|
return (err);
|
2020-08-12 09:07:07 +00:00
|
|
|
|
2020-08-06 13:41:42 +00:00
|
|
|
if (((data.output & mask) != 0) != output)
|
|
|
|
return (EIO);
|
2020-08-12 09:07:07 +00:00
|
|
|
if (output) {
|
|
|
|
switch (*mode) {
|
|
|
|
case OUT_PP:
|
|
|
|
if ((data.pushpull & mask) == 0)
|
|
|
|
return (EIO);
|
|
|
|
break;
|
|
|
|
case OUT_OD:
|
|
|
|
if ((data.pushpull & mask) != 0)
|
|
|
|
return (EIO);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
*mode = (data.pushpull & mask) != 0 ?
|
|
|
|
OUT_PP : OUT_OD;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2020-08-06 13:41:42 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static device_t
|
|
|
|
cp2112_gpio_get_bus(device_t dev)
|
|
|
|
{
|
|
|
|
struct cp2112gpio_softc *sc;
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
return (sc->busdev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cp2112_gpio_pin_max(device_t dev, int *maxpin)
|
|
|
|
{
|
|
|
|
|
|
|
|
*maxpin = CP2112_GPIO_COUNT - 1;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cp2112_gpio_pin_set(device_t dev, uint32_t pin_num, uint32_t pin_value)
|
|
|
|
{
|
|
|
|
struct cp2112gpio_softc *sc;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (pin_num >= CP2112_GPIO_COUNT)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
CP2112GPIO_LOCK(sc);
|
|
|
|
err = cp2112_gpio_write_pin(dev, pin_num, pin_value != 0);
|
|
|
|
CP2112GPIO_UNLOCK(sc);
|
|
|
|
|
|
|
|
return (err);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cp2112_gpio_pin_get(device_t dev, uint32_t pin_num, uint32_t *pin_value)
|
|
|
|
{
|
|
|
|
struct cp2112gpio_softc *sc;
|
|
|
|
int err;
|
|
|
|
bool on;
|
|
|
|
|
|
|
|
if (pin_num >= CP2112_GPIO_COUNT)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
CP2112GPIO_LOCK(sc);
|
|
|
|
err = cp2112_gpio_read_pin(dev, pin_num, &on);
|
|
|
|
CP2112GPIO_UNLOCK(sc);
|
|
|
|
|
|
|
|
if (err == 0)
|
|
|
|
*pin_value = on;
|
|
|
|
return (err);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cp2112_gpio_pin_toggle(device_t dev, uint32_t pin_num)
|
|
|
|
{
|
|
|
|
struct cp2112gpio_softc *sc;
|
|
|
|
int err;
|
|
|
|
bool on;
|
|
|
|
|
|
|
|
if (pin_num >= CP2112_GPIO_COUNT)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
CP2112GPIO_LOCK(sc);
|
|
|
|
err = cp2112_gpio_read_pin(dev, pin_num, &on);
|
|
|
|
if (err == 0)
|
|
|
|
err = cp2112_gpio_write_pin(dev, pin_num, !on);
|
|
|
|
CP2112GPIO_UNLOCK(sc);
|
|
|
|
|
|
|
|
return (err);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cp2112_gpio_pin_getcaps(device_t dev, uint32_t pin_num, uint32_t *caps)
|
|
|
|
{
|
|
|
|
struct cp2112gpio_softc *sc;
|
|
|
|
|
|
|
|
if (pin_num >= CP2112_GPIO_COUNT)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
CP2112GPIO_LOCK(sc);
|
|
|
|
*caps = sc->gpio_caps;
|
|
|
|
CP2112GPIO_UNLOCK(sc);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cp2112_gpio_pin_getflags(device_t dev, uint32_t pin_num, uint32_t *flags)
|
|
|
|
{
|
|
|
|
struct cp2112gpio_softc *sc;
|
|
|
|
|
|
|
|
if (pin_num >= CP2112_GPIO_COUNT)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
CP2112GPIO_LOCK(sc);
|
|
|
|
*flags = sc->pins[pin_num].gp_flags;
|
|
|
|
CP2112GPIO_UNLOCK(sc);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cp2112_gpio_pin_getname(device_t dev, uint32_t pin_num, char *name)
|
|
|
|
{
|
|
|
|
struct cp2112gpio_softc *sc;
|
|
|
|
|
|
|
|
if (pin_num >= CP2112_GPIO_COUNT)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
CP2112GPIO_LOCK(sc);
|
|
|
|
memcpy(name, sc->pins[pin_num].gp_name, GPIOMAXNAME);
|
|
|
|
CP2112GPIO_UNLOCK(sc);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cp2112_gpio_pin_setflags(device_t dev, uint32_t pin_num, uint32_t flags)
|
|
|
|
{
|
|
|
|
struct cp2112gpio_softc *sc;
|
|
|
|
struct gpio_pin *pin;
|
2020-08-12 09:07:07 +00:00
|
|
|
enum cp2112_out_mode out_mode;
|
2020-08-06 13:41:42 +00:00
|
|
|
int err;
|
|
|
|
|
|
|
|
if (pin_num >= CP2112_GPIO_COUNT)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
if ((flags & sc->gpio_caps) != flags)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
if ((flags & (GPIO_PIN_INPUT | GPIO_PIN_OUTPUT)) == 0)
|
|
|
|
return (EINVAL);
|
|
|
|
if ((flags & (GPIO_PIN_INPUT | GPIO_PIN_OUTPUT)) ==
|
|
|
|
(GPIO_PIN_INPUT | GPIO_PIN_OUTPUT)) {
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
|
|
|
if ((flags & GPIO_PIN_INPUT) != 0) {
|
|
|
|
if ((flags & (GPIO_PIN_OPENDRAIN | GPIO_PIN_PUSHPULL)) != 0)
|
|
|
|
return (EINVAL);
|
|
|
|
} else {
|
|
|
|
if ((flags & (GPIO_PIN_OPENDRAIN | GPIO_PIN_PUSHPULL)) ==
|
|
|
|
(GPIO_PIN_OPENDRAIN | GPIO_PIN_PUSHPULL))
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2020-08-12 09:07:07 +00:00
|
|
|
* If neither push-pull or open-drain is explicitly requested, then
|
2020-08-06 13:41:42 +00:00
|
|
|
* preserve the current state.
|
|
|
|
*/
|
2020-08-12 09:07:07 +00:00
|
|
|
out_mode = OUT_KEEP;
|
|
|
|
if ((flags & GPIO_PIN_OUTPUT) != 0) {
|
|
|
|
if ((flags & GPIO_PIN_OPENDRAIN) != 0)
|
|
|
|
out_mode = OUT_OD;
|
|
|
|
if ((flags & GPIO_PIN_PUSHPULL) != 0)
|
|
|
|
out_mode = OUT_PP;
|
2020-08-06 13:41:42 +00:00
|
|
|
}
|
|
|
|
|
2020-08-12 09:07:07 +00:00
|
|
|
CP2112GPIO_LOCK(sc);
|
|
|
|
pin = &sc->pins[pin_num];
|
|
|
|
err = cp2112_gpio_configure_write_pin(dev, pin_num,
|
|
|
|
(flags & GPIO_PIN_OUTPUT) != 0, &out_mode);
|
|
|
|
if (err == 0) {
|
|
|
|
/*
|
|
|
|
* If neither open-drain or push-pull was requested, then see
|
|
|
|
* what hardware actually had. Otherwise, it has been
|
|
|
|
* reconfigured as requested.
|
|
|
|
*/
|
|
|
|
if ((flags & GPIO_PIN_OUTPUT) != 0 &&
|
|
|
|
(flags & (GPIO_PIN_OPENDRAIN | GPIO_PIN_PUSHPULL)) == 0) {
|
|
|
|
KASSERT(out_mode != OUT_KEEP,
|
|
|
|
("impossible current output mode"));
|
|
|
|
if (out_mode == OUT_OD)
|
|
|
|
flags |= GPIO_PIN_OPENDRAIN;
|
|
|
|
else
|
|
|
|
flags |= GPIO_PIN_PUSHPULL;
|
2020-08-06 13:41:42 +00:00
|
|
|
}
|
2020-08-12 09:07:07 +00:00
|
|
|
pin->gp_flags = flags;
|
2020-08-06 13:41:42 +00:00
|
|
|
}
|
2020-08-12 09:07:07 +00:00
|
|
|
CP2112GPIO_UNLOCK(sc);
|
2020-08-06 13:41:42 +00:00
|
|
|
|
2020-08-12 09:07:07 +00:00
|
|
|
return (err);
|
2020-08-06 13:41:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cp2112gpio_probe(device_t dev)
|
|
|
|
{
|
|
|
|
device_set_desc(dev, "CP2112 GPIO interface");
|
|
|
|
return (BUS_PROBE_SPECIFIC);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cp2112gpio_attach(device_t dev)
|
|
|
|
{
|
2020-08-12 09:07:07 +00:00
|
|
|
struct gpio_config_req data;
|
2020-08-06 13:41:42 +00:00
|
|
|
struct cp2112gpio_softc *sc;
|
|
|
|
device_t cp2112;
|
|
|
|
int err;
|
|
|
|
int i;
|
|
|
|
uint8_t mask;
|
|
|
|
|
|
|
|
cp2112 = device_get_parent(dev);
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
sx_init(&sc->gpio_lock, "cp2112 lock");
|
|
|
|
|
|
|
|
sc->gpio_caps = GPIO_PIN_INPUT | GPIO_PIN_OUTPUT | GPIO_PIN_OPENDRAIN |
|
|
|
|
GPIO_PIN_PUSHPULL;
|
|
|
|
|
|
|
|
err = cp2112_get_report(cp2112, CP2112_REQ_GPIO_CFG,
|
|
|
|
&data, sizeof(data));
|
|
|
|
if (err != 0)
|
|
|
|
goto detach;
|
|
|
|
|
|
|
|
for (i = 0; i < CP2112_GPIO_COUNT; i++) {
|
|
|
|
struct gpio_pin *pin;
|
|
|
|
|
|
|
|
mask = (uint8_t)1 << i;
|
|
|
|
pin = &sc->pins[i];
|
|
|
|
pin->gp_flags = 0;
|
|
|
|
|
|
|
|
snprintf(pin->gp_name, GPIOMAXNAME, "GPIO%u", i);
|
|
|
|
pin->gp_name[GPIOMAXNAME - 1] = '\0';
|
|
|
|
|
2020-08-12 09:07:07 +00:00
|
|
|
if ((i == 0 && (data.special & CP2112_GPIO_SPEC_TX0) != 0) ||
|
|
|
|
(i == 1 && (data.special & CP2112_GPIO_SPEC_RX1) != 0) ||
|
|
|
|
(i == 7 && (data.special & CP2112_GPIO_SPEC_CLK7) != 0)) {
|
|
|
|
/* Special mode means that a pin is not for GPIO. */
|
|
|
|
} else if ((data.output & mask) != 0) {
|
2020-08-06 13:41:42 +00:00
|
|
|
pin->gp_flags |= GPIO_PIN_OUTPUT;
|
|
|
|
if ((data.pushpull & mask) != 0)
|
|
|
|
pin->gp_flags |= GPIO_PIN_PUSHPULL;
|
|
|
|
else
|
|
|
|
pin->gp_flags |= GPIO_PIN_OPENDRAIN;
|
|
|
|
} else {
|
|
|
|
pin->gp_flags |= GPIO_PIN_INPUT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
sc->busdev = gpiobus_attach_bus(dev);
|
|
|
|
if (sc->busdev == NULL) {
|
|
|
|
device_printf(dev, "gpiobus_attach_bus failed\n");
|
|
|
|
goto detach;
|
|
|
|
}
|
|
|
|
return (0);
|
|
|
|
|
|
|
|
detach:
|
|
|
|
cp2112gpio_detach(dev);
|
|
|
|
return (ENXIO);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cp2112gpio_detach(device_t dev)
|
|
|
|
{
|
|
|
|
struct cp2112gpio_softc *sc;
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
if (sc->busdev != NULL)
|
|
|
|
gpiobus_detach_bus(dev);
|
|
|
|
sx_destroy(&sc->gpio_lock);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
cp2112iic_intr_write_callback(struct usb_xfer *xfer, usb_error_t error)
|
|
|
|
{
|
|
|
|
struct cp2112iic_softc *sc;
|
|
|
|
struct cp2112_softc *psc;
|
|
|
|
struct usb_page_cache *pc;
|
|
|
|
|
|
|
|
sc = usbd_xfer_softc(xfer);
|
|
|
|
psc = device_get_softc(device_get_parent(sc->dev));
|
|
|
|
|
|
|
|
mtx_assert(&sc->io.lock, MA_OWNED);
|
|
|
|
|
|
|
|
switch (USB_GET_STATE(xfer)) {
|
|
|
|
case USB_ST_SETUP:
|
|
|
|
pc = usbd_xfer_get_frame(xfer, 0);
|
|
|
|
usbd_copy_in(pc, 0, sc->io.out.data, sc->io.out.len);
|
|
|
|
usbd_xfer_set_frame_len(xfer, 0, sc->io.out.len);
|
|
|
|
usbd_xfer_set_frames(xfer, 1);
|
|
|
|
usbd_transfer_submit(xfer);
|
|
|
|
break;
|
|
|
|
case USB_ST_TRANSFERRED:
|
|
|
|
sc->io.out.error = 0;
|
|
|
|
sc->io.out.done = 1;
|
|
|
|
cv_signal(&sc->io.cv);
|
|
|
|
break;
|
|
|
|
default: /* Error */
|
|
|
|
device_printf(sc->dev, "write intr state %d error %d\n",
|
|
|
|
USB_GET_STATE(xfer), error);
|
|
|
|
sc->io.out.error = IIC_EBUSERR;
|
|
|
|
cv_signal(&sc->io.cv);
|
|
|
|
if (error != USB_ERR_CANCELLED) {
|
|
|
|
/* try to clear stall first */
|
|
|
|
usbd_xfer_set_stall(xfer);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
cp2112iic_intr_read_callback(struct usb_xfer *xfer, usb_error_t error)
|
|
|
|
{
|
|
|
|
struct cp2112iic_softc *sc = usbd_xfer_softc(xfer);
|
|
|
|
struct usb_page_cache *pc;
|
|
|
|
int act_len, len;
|
|
|
|
|
|
|
|
mtx_assert(&sc->io.lock, MA_OWNED);
|
|
|
|
usbd_xfer_status(xfer, &act_len, NULL, NULL, NULL);
|
|
|
|
|
|
|
|
switch (USB_GET_STATE(xfer)) {
|
|
|
|
case USB_ST_TRANSFERRED:
|
|
|
|
if (sc->io.in.done) {
|
|
|
|
device_printf(sc->dev,
|
|
|
|
"interrupt while previous is pending, ignored\n");
|
|
|
|
} else if (sc->io.in.len == 0) {
|
|
|
|
uint8_t buf[8];
|
|
|
|
|
|
|
|
/*
|
|
|
|
* There is a spurious Transfer Status Response and
|
|
|
|
* zero-length Read Response during hardware
|
|
|
|
* configuration. Possibly they carry some information
|
|
|
|
* about the initial bus state.
|
|
|
|
*/
|
|
|
|
if (device_is_attached(sc->dev)) {
|
|
|
|
device_printf(sc->dev,
|
|
|
|
"unsolicited interrupt, ignored\n");
|
|
|
|
if (bootverbose) {
|
|
|
|
pc = usbd_xfer_get_frame(xfer, 0);
|
|
|
|
len = MIN(sizeof(buf), act_len);
|
|
|
|
usbd_copy_out(pc, 0, buf, len);
|
|
|
|
device_printf(sc->dev, "data: %*D\n",
|
|
|
|
len, buf, " ");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
pc = usbd_xfer_get_frame(xfer, 0);
|
|
|
|
len = MIN(sizeof(buf), act_len);
|
|
|
|
usbd_copy_out(pc, 0, buf, len);
|
|
|
|
if (buf[0] == CP2112_REQ_SMB_XFER_STATUS_RESP) {
|
|
|
|
device_printf(sc->dev,
|
|
|
|
"initial bus status0 = 0x%02x, "
|
|
|
|
"status1 = 0x%02x\n",
|
|
|
|
buf[1], buf[2]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (act_len == CP2112_REPORT_SIZE) {
|
|
|
|
pc = usbd_xfer_get_frame(xfer, 0);
|
|
|
|
usbd_copy_out(pc, 0, sc->io.in.data, sc->io.in.len);
|
|
|
|
sc->io.in.error = 0;
|
|
|
|
sc->io.in.done = 1;
|
|
|
|
} else {
|
|
|
|
device_printf(sc->dev,
|
|
|
|
"unexpected input report length %u\n", act_len);
|
|
|
|
sc->io.in.error = IIC_EBUSERR;
|
|
|
|
sc->io.in.done = 1;
|
|
|
|
}
|
|
|
|
cv_signal(&sc->io.cv);
|
|
|
|
case USB_ST_SETUP:
|
|
|
|
tr_setup:
|
|
|
|
usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
|
|
|
|
usbd_transfer_submit(xfer);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default: /* Error */
|
|
|
|
device_printf(sc->dev, "read intr state %d error %d\n",
|
|
|
|
USB_GET_STATE(xfer), error);
|
|
|
|
|
|
|
|
sc->io.in.error = IIC_EBUSERR;
|
|
|
|
sc->io.in.done = 1;
|
|
|
|
cv_signal(&sc->io.cv);
|
|
|
|
if (error != USB_ERR_CANCELLED) {
|
|
|
|
/* try to clear stall first */
|
|
|
|
usbd_xfer_set_stall(xfer);
|
|
|
|
goto tr_setup;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct usb_config cp2112iic_config[CP2112_N_TRANSFER] = {
|
|
|
|
[CP2112_INTR_OUT] = {
|
|
|
|
.type = UE_INTERRUPT,
|
|
|
|
.endpoint = UE_ADDR_ANY,
|
|
|
|
.direction = UE_DIR_OUT,
|
|
|
|
.flags = { .pipe_bof = 1, .no_pipe_ok = 1, },
|
|
|
|
.bufsize = 0, /* use wMaxPacketSize */
|
|
|
|
.callback = &cp2112iic_intr_write_callback,
|
|
|
|
},
|
|
|
|
[CP2112_INTR_IN] = {
|
|
|
|
.type = UE_INTERRUPT,
|
|
|
|
.endpoint = UE_ADDR_ANY,
|
|
|
|
.direction = UE_DIR_IN,
|
|
|
|
.flags = { .pipe_bof = 1, .short_xfer_ok = 1, },
|
|
|
|
.bufsize = 0, /* use wMaxPacketSize */
|
|
|
|
.callback = &cp2112iic_intr_read_callback,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static int
|
|
|
|
cp2112iic_send_req(struct cp2112iic_softc *sc, const void *data,
|
|
|
|
uint16_t len)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
mtx_assert(&sc->io.lock, MA_OWNED);
|
|
|
|
KASSERT(sc->io.out.done == 0, ("%s: conflicting request", __func__));
|
|
|
|
|
|
|
|
sc->io.out.data = data;
|
|
|
|
sc->io.out.len = len;
|
|
|
|
|
|
|
|
DTRACE_PROBE1(send__req, uint8_t, *(const uint8_t *)data);
|
|
|
|
|
|
|
|
usbd_transfer_start(sc->xfers[CP2112_INTR_OUT]);
|
|
|
|
|
|
|
|
while (!sc->io.out.done)
|
|
|
|
cv_wait(&sc->io.cv, &sc->io.lock);
|
|
|
|
|
|
|
|
usbd_transfer_stop(sc->xfers[CP2112_INTR_OUT]);
|
|
|
|
|
|
|
|
sc->io.out.done = 0;
|
|
|
|
sc->io.out.data = NULL;
|
|
|
|
sc->io.out.len = 0;
|
|
|
|
err = sc->io.out.error;
|
|
|
|
if (err != 0) {
|
|
|
|
device_printf(sc->dev, "output report 0x%02x failed: %d\n",
|
|
|
|
*(const uint8_t*)data, err);
|
|
|
|
}
|
|
|
|
return (err);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cp2112iic_req_resp(struct cp2112iic_softc *sc, const void *req_data,
|
|
|
|
uint16_t req_len, void *resp_data, uint16_t resp_len)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
mtx_assert(&sc->io.lock, MA_OWNED);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Prepare to receive a response interrupt even before the
|
|
|
|
* request transfer is confirmed (USB_ST_TRANSFERED).
|
|
|
|
*/
|
|
|
|
KASSERT(sc->io.in.done == 0, ("%s: conflicting request", __func__));
|
|
|
|
sc->io.in.len = resp_len;
|
|
|
|
sc->io.in.data = resp_data;
|
|
|
|
|
|
|
|
err = cp2112iic_send_req(sc, req_data, req_len);
|
|
|
|
if (err != 0) {
|
|
|
|
sc->io.in.len = 0;
|
|
|
|
sc->io.in.data = NULL;
|
|
|
|
return (err);
|
|
|
|
}
|
|
|
|
|
|
|
|
while (!sc->io.in.done)
|
|
|
|
cv_wait(&sc->io.cv, &sc->io.lock);
|
|
|
|
|
|
|
|
err = sc->io.in.error;
|
|
|
|
sc->io.in.done = 0;
|
|
|
|
sc->io.in.error = 0;
|
|
|
|
sc->io.in.len = 0;
|
|
|
|
sc->io.in.data = NULL;
|
|
|
|
return (err);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cp2112iic_check_req_status(struct cp2112iic_softc *sc)
|
|
|
|
{
|
2020-08-12 09:07:07 +00:00
|
|
|
struct i2c_xfer_status_req xfer_status_req;
|
|
|
|
struct i2c_xfer_status_resp xfer_status_resp;
|
2020-08-06 13:41:42 +00:00
|
|
|
int err;
|
|
|
|
|
|
|
|
mtx_assert(&sc->io.lock, MA_OWNED);
|
|
|
|
|
|
|
|
do {
|
|
|
|
xfer_status_req.id = CP2112_REQ_SMB_XFER_STATUS_REQ;
|
|
|
|
xfer_status_req.request = 1;
|
|
|
|
err = cp2112iic_req_resp(sc,
|
|
|
|
&xfer_status_req, sizeof(xfer_status_req),
|
|
|
|
&xfer_status_resp, sizeof(xfer_status_resp));
|
|
|
|
|
|
|
|
if (xfer_status_resp.id != CP2112_REQ_SMB_XFER_STATUS_RESP) {
|
|
|
|
device_printf(sc->dev,
|
|
|
|
"unexpected response 0x%02x to status request\n",
|
|
|
|
xfer_status_resp.id);
|
|
|
|
err = IIC_EBUSERR;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
DTRACE_PROBE4(xfer__status, uint8_t, xfer_status_resp.status0,
|
|
|
|
uint8_t, xfer_status_resp.status1,
|
|
|
|
uint16_t, be16toh(xfer_status_resp.status2),
|
|
|
|
uint16_t, be16toh(xfer_status_resp.status3));
|
|
|
|
|
|
|
|
switch (xfer_status_resp.status0) {
|
|
|
|
case CP2112_IIC_STATUS0_IDLE:
|
|
|
|
err = IIC_ESTATUS;
|
|
|
|
break;
|
|
|
|
case CP2112_IIC_STATUS0_BUSY:
|
|
|
|
err = ERESTART; /* non-I2C, special handling */
|
|
|
|
break;
|
|
|
|
case CP2112_IIC_STATUS0_CMP:
|
|
|
|
err = IIC_NOERR;
|
|
|
|
break;
|
|
|
|
case CP2112_IIC_STATUS0_ERROR:
|
|
|
|
switch (xfer_status_resp.status1) {
|
|
|
|
case CP2112_IIC_STATUS1_TIMEOUT_NACK:
|
|
|
|
err = IIC_ENOACK;
|
|
|
|
break;
|
|
|
|
case CP2112_IIC_STATUS1_TIMEOUT_BUS:
|
|
|
|
err = IIC_ETIMEOUT;
|
|
|
|
break;
|
|
|
|
case CP2112_IIC_STATUS1_ARB_LOST:
|
|
|
|
err = IIC_EBUSBSY;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
device_printf(sc->dev,
|
|
|
|
"i2c error, status = 0x%02x\n",
|
|
|
|
xfer_status_resp.status1);
|
|
|
|
err = IIC_ESTATUS;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
device_printf(sc->dev,
|
|
|
|
"unknown i2c xfer status0 0x%02x\n",
|
|
|
|
xfer_status_resp.status0);
|
|
|
|
err = IIC_EBUSERR;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
} while (err == ERESTART);
|
|
|
|
out:
|
|
|
|
return (err);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cp2112iic_read_data(struct cp2112iic_softc *sc, void *data, uint16_t in_len,
|
|
|
|
uint16_t *out_len)
|
|
|
|
{
|
2020-08-12 09:07:07 +00:00
|
|
|
struct i2c_data_read_force_send_req data_read_force_send;
|
|
|
|
struct i2c_data_read_resp data_read_resp;
|
2020-08-06 13:41:42 +00:00
|
|
|
int err;
|
|
|
|
|
|
|
|
mtx_assert(&sc->io.lock, MA_OWNED);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Prepare to receive a response interrupt even before the request
|
|
|
|
* transfer is confirmed (USB_ST_TRANSFERED).
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (in_len > sizeof(data_read_resp.data))
|
|
|
|
in_len = sizeof(data_read_resp.data);
|
|
|
|
data_read_force_send.id = CP2112_REQ_SMB_READ_FORCE_SEND;
|
2020-08-12 09:07:07 +00:00
|
|
|
data_read_force_send.len = htobe16(in_len);
|
2020-08-06 13:41:42 +00:00
|
|
|
err = cp2112iic_req_resp(sc,
|
|
|
|
&data_read_force_send, sizeof(data_read_force_send),
|
|
|
|
&data_read_resp, sizeof(data_read_resp));
|
|
|
|
if (err != 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (data_read_resp.id != CP2112_REQ_SMB_READ_RESPONSE) {
|
|
|
|
device_printf(sc->dev,
|
|
|
|
"unexpected response 0x%02x to data read request\n",
|
|
|
|
data_read_resp.id);
|
|
|
|
err = IIC_EBUSERR;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
DTRACE_PROBE2(read__response, uint8_t, data_read_resp.status,
|
2020-08-12 09:07:07 +00:00
|
|
|
uint8_t, data_read_resp.len);
|
2020-08-06 13:41:42 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We expect either the request completed status or, more typical for
|
|
|
|
* this driver, the bus idle status because of the preceding
|
|
|
|
* Force Read Status command (which is not an I2C request).
|
|
|
|
*/
|
|
|
|
if (data_read_resp.status != CP2112_IIC_STATUS0_CMP &&
|
|
|
|
data_read_resp.status != CP2112_IIC_STATUS0_IDLE) {
|
|
|
|
err = IIC_EBUSERR;
|
|
|
|
goto out;
|
|
|
|
}
|
2020-08-12 09:07:07 +00:00
|
|
|
if (data_read_resp.len > in_len) {
|
2020-08-06 13:41:42 +00:00
|
|
|
device_printf(sc->dev, "device returns more data than asked\n");
|
|
|
|
err = IIC_EOVERFLOW;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2020-08-12 09:07:07 +00:00
|
|
|
*out_len = data_read_resp.len;
|
2020-08-06 13:41:42 +00:00
|
|
|
if (*out_len > 0)
|
|
|
|
memcpy(data, data_read_resp.data, *out_len);
|
|
|
|
out:
|
|
|
|
return (err);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cp2112iic_transfer(device_t dev, struct iic_msg *msgs, uint32_t nmsgs)
|
|
|
|
{
|
|
|
|
struct cp2112iic_softc *sc = device_get_softc(dev);
|
|
|
|
struct cp2112_softc *psc = device_get_softc(device_get_parent(dev));
|
|
|
|
const char *reason = NULL;
|
|
|
|
uint32_t i;
|
|
|
|
uint16_t read_off, to_read;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The hardware interface imposes limits on allowed I2C messages.
|
|
|
|
* It is not possible to explicitly send a start or stop.
|
|
|
|
* It is not possible to do a zero length transfer.
|
|
|
|
* For this reason it's impossible to send a message with no data
|
|
|
|
* at all (like an SMBus quick message).
|
|
|
|
* Each read or write transfer beginning with the start condition
|
|
|
|
* and ends with the stop condition. The only exception is that
|
|
|
|
* it is possible to have a write transfer followed by a read
|
|
|
|
* transfer to the same slave with the repeated start condition
|
|
|
|
* between them.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < nmsgs; i++) {
|
|
|
|
if (i == 0 && (msgs[i].flags & IIC_M_NOSTART) != 0) {
|
|
|
|
reason = "first message without start";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (i == nmsgs - 1 && (msgs[i].flags & IIC_M_NOSTOP) != 0) {
|
|
|
|
reason = "last message without stop";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (msgs[i].len == 0) {
|
|
|
|
reason = "message with no data";
|
|
|
|
break;
|
|
|
|
}
|
2020-08-12 09:07:07 +00:00
|
|
|
if ((msgs[i].flags & IIC_M_RD) != 0 &&
|
|
|
|
msgs[i].len > CP2112_IIC_MAX_READ_LEN) {
|
2020-08-06 13:41:42 +00:00
|
|
|
reason = "too long read";
|
|
|
|
break;
|
|
|
|
}
|
2020-08-12 09:07:07 +00:00
|
|
|
if ((msgs[i].flags & IIC_M_RD) == 0 &&
|
|
|
|
msgs[i].len > SIZEOF_FIELD(i2c_write_req, data)) {
|
2020-08-06 13:41:42 +00:00
|
|
|
reason = "too long write";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ((msgs[i].flags & IIC_M_NOSTART) != 0) {
|
|
|
|
reason = "message without start or repeated start";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ((msgs[i].flags & IIC_M_NOSTOP) != 0 &&
|
|
|
|
(msgs[i].flags & IIC_M_RD) != 0) {
|
|
|
|
reason = "read without stop";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ((msgs[i].flags & IIC_M_NOSTOP) != 0 &&
|
|
|
|
psc->sc_version < CP2112_IIC_REPSTART_VER) {
|
|
|
|
reason = "write without stop";
|
|
|
|
break;
|
|
|
|
}
|
2020-08-12 09:07:07 +00:00
|
|
|
if ((msgs[i].flags & IIC_M_NOSTOP) != 0 &&
|
|
|
|
msgs[i].len > SIZEOF_FIELD(i2c_write_read_req, wdata)) {
|
2020-08-06 13:41:42 +00:00
|
|
|
reason = "too long write without stop";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (i > 0) {
|
|
|
|
if ((msgs[i - 1].flags & IIC_M_NOSTOP) != 0 &&
|
|
|
|
msgs[i].slave != msgs[i - 1].slave) {
|
|
|
|
reason = "change of slave without stop";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ((msgs[i - 1].flags & IIC_M_NOSTOP) != 0 &&
|
|
|
|
(msgs[i].flags & IIC_M_RD) == 0) {
|
|
|
|
reason = "write after repeated start";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (reason != NULL) {
|
|
|
|
if (bootverbose)
|
|
|
|
device_printf(dev, "unsupported i2c message: %s\n",
|
|
|
|
reason);
|
|
|
|
return (IIC_ENOTSUPP);
|
|
|
|
}
|
|
|
|
|
|
|
|
mtx_lock(&sc->io.lock);
|
|
|
|
|
|
|
|
for (i = 0; i < nmsgs; i++) {
|
|
|
|
if (i + 1 < nmsgs && (msgs[i].flags & IIC_M_NOSTOP) != 0) {
|
|
|
|
/*
|
|
|
|
* Combine <write><repeated start><read> into a single
|
|
|
|
* CP2112 operation.
|
|
|
|
*/
|
2020-08-12 09:07:07 +00:00
|
|
|
struct i2c_write_read_req req;
|
2020-08-06 13:41:42 +00:00
|
|
|
|
2020-08-12 09:07:07 +00:00
|
|
|
KASSERT((msgs[i].flags & IIC_M_RD) == 0,
|
|
|
|
("read without stop"));
|
|
|
|
KASSERT((msgs[i + 1].flags & IIC_M_RD) != 0,
|
|
|
|
("write after write without stop"));
|
2020-08-06 13:41:42 +00:00
|
|
|
req.id = CP2112_REQ_SMB_WRITE_READ;
|
|
|
|
req.slave = msgs[i].slave & ~LSB;
|
|
|
|
to_read = msgs[i + 1].len;
|
|
|
|
req.rlen = htobe16(to_read);
|
|
|
|
req.wlen = msgs[i].len;
|
|
|
|
memcpy(req.wdata, msgs[i].buf, msgs[i].len);
|
|
|
|
err = cp2112iic_send_req(sc, &req, msgs[i].len + 5);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The next message is already handled.
|
|
|
|
* Also needed for read data to go into the right msg.
|
|
|
|
*/
|
|
|
|
i++;
|
|
|
|
} else if ((msgs[i].flags & IIC_M_RD) != 0) {
|
2020-08-12 09:07:07 +00:00
|
|
|
struct i2c_read_req req;
|
2020-08-06 13:41:42 +00:00
|
|
|
|
|
|
|
req.id = CP2112_REQ_SMB_READ;
|
|
|
|
req.slave = msgs[i].slave & ~LSB;
|
|
|
|
to_read = msgs[i].len;
|
|
|
|
req.len = htobe16(to_read);
|
|
|
|
err = cp2112iic_send_req(sc, &req, sizeof(req));
|
|
|
|
} else {
|
2020-08-12 09:07:07 +00:00
|
|
|
struct i2c_write_req req;
|
2020-08-06 13:41:42 +00:00
|
|
|
|
|
|
|
req.id = CP2112_REQ_SMB_WRITE;
|
|
|
|
req.slave = msgs[i].slave & ~LSB;
|
|
|
|
req.len = msgs[i].len;
|
|
|
|
memcpy(req.data, msgs[i].buf, msgs[i].len);
|
|
|
|
to_read = 0;
|
|
|
|
err = cp2112iic_send_req(sc, &req, msgs[i].len + 3);
|
|
|
|
}
|
|
|
|
if (err != 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
err = cp2112iic_check_req_status(sc);
|
|
|
|
if (err != 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
read_off = 0;
|
|
|
|
while (to_read > 0) {
|
|
|
|
uint16_t act_read;
|
|
|
|
|
|
|
|
err = cp2112iic_read_data(sc, msgs[i].buf + read_off,
|
|
|
|
to_read, &act_read);
|
|
|
|
if (err != 0)
|
|
|
|
break;
|
|
|
|
KASSERT(act_read <= to_read, ("cp2112iic_read_data "
|
|
|
|
"returned more data than asked"));
|
|
|
|
read_off += act_read;
|
|
|
|
to_read -= act_read;
|
|
|
|
}
|
|
|
|
if (err != 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
mtx_unlock(&sc->io.lock);
|
|
|
|
return (err);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cp2112iic_reset(device_t dev, u_char speed, u_char addr, u_char *oldaddr)
|
|
|
|
{
|
2020-08-12 09:07:07 +00:00
|
|
|
struct i2c_cfg_req i2c_cfg;
|
2020-08-06 13:41:42 +00:00
|
|
|
struct cp2112iic_softc *sc;
|
|
|
|
device_t cp2112;
|
|
|
|
u_int busfreq;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
cp2112 = device_get_parent(dev);
|
|
|
|
if (sc->iicbus_dev == NULL)
|
|
|
|
busfreq = 100000;
|
|
|
|
else
|
|
|
|
busfreq = IICBUS_GET_FREQUENCY(sc->iicbus_dev, speed);
|
|
|
|
|
|
|
|
err = cp2112_get_report(cp2112, CP2112_REQ_SMB_CFG,
|
2020-08-12 09:07:07 +00:00
|
|
|
&i2c_cfg, sizeof(i2c_cfg));
|
2020-08-06 13:41:42 +00:00
|
|
|
if (err != 0) {
|
|
|
|
device_printf(dev, "failed to get CP2112_REQ_SMB_CFG report\n");
|
|
|
|
return (err);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (oldaddr != NULL)
|
2020-08-12 09:07:07 +00:00
|
|
|
*oldaddr = i2c_cfg.slave_addr;
|
2020-08-06 13:41:42 +00:00
|
|
|
/*
|
|
|
|
* For simplicity we do not enable Auto Send Read
|
|
|
|
* because of erratum CP2112_E101 (fixed in version 3).
|
|
|
|
*
|
|
|
|
* TODO: set I2C parameters based on configuration preferences:
|
|
|
|
* - read and write timeouts (no timeout by default),
|
|
|
|
* - SCL low timeout (disabled by default),
|
|
|
|
* etc.
|
|
|
|
*
|
|
|
|
* TODO: should the device reset request (0x01) be sent?
|
|
|
|
* If the device disconnects as a result, then no.
|
|
|
|
*/
|
2020-08-12 09:07:07 +00:00
|
|
|
i2c_cfg.speed = htobe32(busfreq);
|
2020-08-06 13:41:42 +00:00
|
|
|
if (addr != 0)
|
2020-08-12 09:07:07 +00:00
|
|
|
i2c_cfg.slave_addr = addr;
|
|
|
|
i2c_cfg.auto_send_read = 0;
|
|
|
|
i2c_cfg.retry_count = htobe16(1);
|
|
|
|
i2c_cfg.scl_low_timeout = 0;
|
2020-08-06 13:41:42 +00:00
|
|
|
if (bootverbose) {
|
2020-08-12 09:07:07 +00:00
|
|
|
device_printf(dev, "speed %d Hz\n", be32toh(i2c_cfg.speed));
|
|
|
|
device_printf(dev, "slave addr 0x%02x\n", i2c_cfg.slave_addr);
|
2020-08-06 13:41:42 +00:00
|
|
|
device_printf(dev, "auto send read %s\n",
|
2020-08-12 09:07:07 +00:00
|
|
|
i2c_cfg.auto_send_read ? "on" : "off");
|
2020-08-06 13:41:42 +00:00
|
|
|
device_printf(dev, "write timeout %d ms (0 - disabled)\n",
|
2020-08-12 09:07:07 +00:00
|
|
|
be16toh(i2c_cfg.write_timeout));
|
2020-08-06 13:41:42 +00:00
|
|
|
device_printf(dev, "read timeout %d ms (0 - disabled)\n",
|
2020-08-12 09:07:07 +00:00
|
|
|
be16toh(i2c_cfg.read_timeout));
|
2020-08-06 13:41:42 +00:00
|
|
|
device_printf(dev, "scl low timeout %s\n",
|
2020-08-12 09:07:07 +00:00
|
|
|
i2c_cfg.scl_low_timeout ? "on" : "off");
|
2020-08-06 13:41:42 +00:00
|
|
|
device_printf(dev, "retry count %d (0 - no limit)\n",
|
2020-08-12 09:07:07 +00:00
|
|
|
be16toh(i2c_cfg.retry_count));
|
2020-08-06 13:41:42 +00:00
|
|
|
}
|
|
|
|
err = cp2112_set_report(cp2112, CP2112_REQ_SMB_CFG,
|
2020-08-12 09:07:07 +00:00
|
|
|
&i2c_cfg, sizeof(i2c_cfg));
|
2020-08-06 13:41:42 +00:00
|
|
|
if (err != 0) {
|
|
|
|
device_printf(dev, "failed to set CP2112_REQ_SMB_CFG report\n");
|
|
|
|
return (err);
|
|
|
|
}
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cp2112iic_probe(device_t dev)
|
|
|
|
{
|
|
|
|
device_set_desc(dev, "CP2112 I2C interface");
|
|
|
|
return (BUS_PROBE_SPECIFIC);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cp2112iic_attach(device_t dev)
|
|
|
|
{
|
|
|
|
struct cp2112iic_softc *sc;
|
|
|
|
struct cp2112_softc *psc;
|
|
|
|
device_t cp2112;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
sc->dev = dev;
|
|
|
|
cp2112 = device_get_parent(dev);
|
|
|
|
psc = device_get_softc(cp2112);
|
|
|
|
|
|
|
|
mtx_init(&sc->io.lock, "cp2112iic lock", NULL, MTX_DEF | MTX_RECURSE);
|
|
|
|
cv_init(&sc->io.cv, "cp2112iic cv");
|
|
|
|
|
|
|
|
err = usbd_transfer_setup(psc->sc_udev,
|
|
|
|
&psc->sc_iface_index, sc->xfers, cp2112iic_config,
|
|
|
|
nitems(cp2112iic_config), sc, &sc->io.lock);
|
|
|
|
if (err != 0) {
|
|
|
|
device_printf(dev, "usbd_transfer_setup failed %d\n", err);
|
|
|
|
goto detach;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Prepare to receive interrupts. */
|
|
|
|
mtx_lock(&sc->io.lock);
|
|
|
|
usbd_transfer_start(sc->xfers[CP2112_INTR_IN]);
|
|
|
|
mtx_unlock(&sc->io.lock);
|
|
|
|
|
|
|
|
sc->iicbus_dev = device_add_child(dev, "iicbus", -1);
|
|
|
|
if (sc->iicbus_dev == NULL) {
|
|
|
|
device_printf(dev, "iicbus creation failed\n");
|
|
|
|
err = ENXIO;
|
|
|
|
goto detach;
|
|
|
|
}
|
|
|
|
bus_generic_attach(dev);
|
|
|
|
return (0);
|
|
|
|
|
|
|
|
detach:
|
|
|
|
cp2112iic_detach(dev);
|
|
|
|
return (err);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cp2112iic_detach(device_t dev)
|
|
|
|
{
|
|
|
|
struct cp2112iic_softc *sc;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
err = bus_generic_detach(dev);
|
|
|
|
if (err != 0)
|
|
|
|
return (err);
|
|
|
|
device_delete_children(dev);
|
|
|
|
|
|
|
|
mtx_lock(&sc->io.lock);
|
|
|
|
usbd_transfer_stop(sc->xfers[CP2112_INTR_IN]);
|
|
|
|
mtx_unlock(&sc->io.lock);
|
|
|
|
usbd_transfer_unsetup(sc->xfers, nitems(cp2112iic_config));
|
|
|
|
|
|
|
|
cv_destroy(&sc->io.cv);
|
|
|
|
mtx_destroy(&sc->io.lock);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2020-08-12 09:07:07 +00:00
|
|
|
static device_method_t cp2112hid_methods[] = {
|
|
|
|
DEVMETHOD(device_probe, cp2112_probe),
|
|
|
|
DEVMETHOD(device_attach, cp2112_attach),
|
|
|
|
DEVMETHOD(device_detach, cp2112_detach),
|
|
|
|
|
|
|
|
DEVMETHOD_END
|
|
|
|
};
|
|
|
|
|
|
|
|
static driver_t cp2112hid_driver = {
|
|
|
|
.name = "cp2112hid",
|
|
|
|
.methods = cp2112hid_methods,
|
|
|
|
.size = sizeof(struct cp2112_softc),
|
|
|
|
};
|
|
|
|
|
|
|
|
static devclass_t cp2112hid_devclass;
|
|
|
|
DRIVER_MODULE(cp2112hid, uhub, cp2112hid_driver, cp2112hid_devclass,
|
|
|
|
NULL, NULL);
|
|
|
|
MODULE_DEPEND(cp2112hid, usb, 1, 1, 1);
|
|
|
|
MODULE_VERSION(cp2112hid, 1);
|
|
|
|
USB_PNP_HOST_INFO(cp2112_devs);
|
|
|
|
|
|
|
|
static device_method_t cp2112gpio_methods[] = {
|
|
|
|
/* Device */
|
|
|
|
DEVMETHOD(device_probe, cp2112gpio_probe),
|
|
|
|
DEVMETHOD(device_attach, cp2112gpio_attach),
|
|
|
|
DEVMETHOD(device_detach, cp2112gpio_detach),
|
|
|
|
|
|
|
|
/* GPIO */
|
|
|
|
DEVMETHOD(gpio_get_bus, cp2112_gpio_get_bus),
|
|
|
|
DEVMETHOD(gpio_pin_max, cp2112_gpio_pin_max),
|
|
|
|
DEVMETHOD(gpio_pin_get, cp2112_gpio_pin_get),
|
|
|
|
DEVMETHOD(gpio_pin_set, cp2112_gpio_pin_set),
|
|
|
|
DEVMETHOD(gpio_pin_toggle, cp2112_gpio_pin_toggle),
|
|
|
|
DEVMETHOD(gpio_pin_getname, cp2112_gpio_pin_getname),
|
|
|
|
DEVMETHOD(gpio_pin_getcaps, cp2112_gpio_pin_getcaps),
|
|
|
|
DEVMETHOD(gpio_pin_getflags, cp2112_gpio_pin_getflags),
|
|
|
|
DEVMETHOD(gpio_pin_setflags, cp2112_gpio_pin_setflags),
|
|
|
|
|
|
|
|
DEVMETHOD_END
|
|
|
|
};
|
|
|
|
|
|
|
|
static driver_t cp2112gpio_driver = {
|
|
|
|
.name = "gpio",
|
|
|
|
.methods = cp2112gpio_methods,
|
|
|
|
.size = sizeof(struct cp2112gpio_softc),
|
|
|
|
};
|
|
|
|
|
|
|
|
static devclass_t cp2112gpio_devclass;
|
|
|
|
DRIVER_MODULE(cp2112gpio, cp2112hid, cp2112gpio_driver, cp2112gpio_devclass,
|
|
|
|
NULL, NULL);
|
|
|
|
MODULE_DEPEND(cp2112gpio, cp2112hid, 1, 1, 1);
|
|
|
|
MODULE_DEPEND(cp2112gpio, gpiobus, 1, 1, 1);
|
|
|
|
MODULE_VERSION(cp2112gpio, 1);
|
|
|
|
|
2020-08-06 13:41:42 +00:00
|
|
|
static device_method_t cp2112iic_methods[] = {
|
|
|
|
/* Device interface */
|
|
|
|
DEVMETHOD(device_probe, cp2112iic_probe),
|
|
|
|
DEVMETHOD(device_attach, cp2112iic_attach),
|
|
|
|
DEVMETHOD(device_detach, cp2112iic_detach),
|
|
|
|
|
|
|
|
/* I2C methods */
|
|
|
|
DEVMETHOD(iicbus_transfer, cp2112iic_transfer),
|
|
|
|
DEVMETHOD(iicbus_reset, cp2112iic_reset),
|
|
|
|
DEVMETHOD(iicbus_callback, iicbus_null_callback),
|
|
|
|
|
|
|
|
DEVMETHOD_END
|
|
|
|
};
|
|
|
|
|
|
|
|
static driver_t cp2112iic_driver = {
|
|
|
|
"iichb",
|
|
|
|
cp2112iic_methods,
|
|
|
|
sizeof(struct cp2112iic_softc)
|
|
|
|
};
|
|
|
|
|
|
|
|
static devclass_t cp2112iic_devclass;
|
|
|
|
DRIVER_MODULE(cp2112iic, cp2112hid, cp2112iic_driver, cp2112iic_devclass,
|
|
|
|
NULL, NULL);
|
|
|
|
MODULE_DEPEND(cp2112iic, cp2112hid, 1, 1, 1);
|
|
|
|
MODULE_DEPEND(cp2112iic, iicbus, IICBUS_MINVER, IICBUS_PREFVER, IICBUS_MAXVER);
|
|
|
|
MODULE_VERSION(cp2112iic, 1);
|