Date: Sun, 29 Mar 2020 23:38:55 +0000 (UTC) From: Vladimir Kondratyev <wulf@FreeBSD.org> To: src-committers@freebsd.org, svn-src-all@freebsd.org, svn-src-stable@freebsd.org, svn-src-stable-12@freebsd.org Subject: svn commit: r359431 - in stable/12/sys: conf dev/acpica dev/ichiic dev/iicbus modules/i2c/iicbus Message-ID: <202003292338.02TNct6k007242@repo.freebsd.org>
next in thread | raw e-mail | index | archive | help
Author: wulf Date: Sun Mar 29 23:38:55 2020 New Revision: 359431 URL: https://svnweb.freebsd.org/changeset/base/359431 Log: MFC r358818: acpi: Fix stalled value returned by acpi_get_device() after device deletion Newbus device reference attached to ACPI handle is not cleared when newbus device is deleted with devctl(8) delete command. Fix that with calling of AcpiDetachData() from "child_deleted" bus method like acpi_pci driver does. MFC r358819: acpi: Export functions required by upcoming acpi_iicbus driver. MFC r358820: iicbus(4): Add support for ACPI-based children enumeration When iicbus is attached as child of Designware I2C controller it scans all ACPI nodes for "I2C Serial Bus Connection Resource Descriptor" described in section 19.6.57 of ACPI specs. If such a descriptor is found, I2C child is added to iicbus, it's I2C address, IRQ resource and ACPI handle are added to ivars. Existing ACPI bus-hosted child is deleted afterwards. The driver also installs so called "I2C address space handler" which is disabled by default as nontested. Set hw.iicbus.enable_acpi_space_handler loader tunable to 1 to enable it. Reviewed by: markj Differential Revision: https://reviews.freebsd.org/D22901 Added: stable/12/sys/dev/iicbus/acpi_iicbus.c - copied unchanged from r358820, head/sys/dev/iicbus/acpi_iicbus.c Modified: stable/12/sys/conf/files stable/12/sys/dev/acpica/acpi.c stable/12/sys/dev/acpica/acpivar.h stable/12/sys/dev/ichiic/ig4_iic.c stable/12/sys/dev/iicbus/iicbus.c stable/12/sys/dev/iicbus/iicbus.h stable/12/sys/modules/i2c/iicbus/Makefile Directory Properties: stable/12/ (props changed) Modified: stable/12/sys/conf/files ============================================================================== --- stable/12/sys/conf/files Sun Mar 29 23:33:12 2020 (r359430) +++ stable/12/sys/conf/files Sun Mar 29 23:38:55 2020 (r359431) @@ -1843,6 +1843,7 @@ dev/ichsmb/ichsmb_pci.c optional ichsmb pci dev/ida/ida.c optional ida dev/ida/ida_disk.c optional ida dev/ida/ida_pci.c optional ida pci +dev/iicbus/acpi_iicbus.c optional acpi iicbus dev/iicbus/ad7418.c optional ad7418 dev/iicbus/ads111x.c optional ads111x dev/iicbus/ds1307.c optional ds1307 Modified: stable/12/sys/dev/acpica/acpi.c ============================================================================== --- stable/12/sys/dev/acpica/acpi.c Sun Mar 29 23:33:12 2020 (r359430) +++ stable/12/sys/dev/acpica/acpi.c Sun Mar 29 23:38:55 2020 (r359431) @@ -120,6 +120,7 @@ static device_t acpi_add_child(device_t bus, u_int ord static int acpi_print_child(device_t bus, device_t child); static void acpi_probe_nomatch(device_t bus, device_t child); static void acpi_driver_added(device_t dev, driver_t *driver); +static void acpi_child_deleted(device_t dev, device_t child); static int acpi_read_ivar(device_t dev, device_t child, int index, uintptr_t *result); static int acpi_write_ivar(device_t dev, device_t child, int index, @@ -148,7 +149,6 @@ static ACPI_STATUS acpi_device_scan_cb(ACPI_HANDLE h, void *context, void **retval); static ACPI_STATUS acpi_device_scan_children(device_t bus, device_t dev, int max_depth, acpi_scan_cb_t user_fn, void *arg); -static int acpi_set_powerstate(device_t child, int state); static int acpi_isa_pnp_probe(device_t bus, device_t child, struct isa_pnp_id *ids); static void acpi_probe_children(device_t bus); @@ -160,7 +160,6 @@ static ACPI_STATUS acpi_sleep_disable(struct acpi_soft static ACPI_STATUS acpi_EnterSleepState(struct acpi_softc *sc, int state); static void acpi_shutdown_final(void *arg, int howto); static void acpi_enable_fixed_events(struct acpi_softc *sc); -static BOOLEAN acpi_has_hid(ACPI_HANDLE handle); static void acpi_resync_clock(struct acpi_softc *sc); static int acpi_wake_sleep_prep(ACPI_HANDLE handle, int sstate); static int acpi_wake_run_prep(ACPI_HANDLE handle, int sstate); @@ -198,6 +197,7 @@ static device_method_t acpi_methods[] = { DEVMETHOD(bus_print_child, acpi_print_child), DEVMETHOD(bus_probe_nomatch, acpi_probe_nomatch), DEVMETHOD(bus_driver_added, acpi_driver_added), + DEVMETHOD(bus_child_deleted, acpi_child_deleted), DEVMETHOD(bus_read_ivar, acpi_read_ivar), DEVMETHOD(bus_write_ivar, acpi_write_ivar), DEVMETHOD(bus_get_resource_list, acpi_get_rlist), @@ -871,14 +871,12 @@ acpi_child_location_str_method(device_t cbdev, device_ } /* PnP information for devctl(8) */ -static int -acpi_child_pnpinfo_str_method(device_t cbdev, device_t child, char *buf, - size_t buflen) +int +acpi_pnpinfo_str(ACPI_HANDLE handle, char *buf, size_t buflen) { - struct acpi_device *dinfo = device_get_ivars(child); ACPI_DEVICE_INFO *adinfo; - if (ACPI_FAILURE(AcpiGetObjectInfo(dinfo->ad_handle, &adinfo))) { + if (ACPI_FAILURE(AcpiGetObjectInfo(handle, &adinfo))) { snprintf(buf, buflen, "unknown"); return (0); } @@ -893,7 +891,28 @@ acpi_child_pnpinfo_str_method(device_t cbdev, device_t return (0); } +static int +acpi_child_pnpinfo_str_method(device_t cbdev, device_t child, char *buf, + size_t buflen) +{ + struct acpi_device *dinfo = device_get_ivars(child); + + return (acpi_pnpinfo_str(dinfo->ad_handle, buf, buflen)); +} + /* + * Handle device deletion. + */ +static void +acpi_child_deleted(device_t dev, device_t child) +{ + struct acpi_device *dinfo = device_get_ivars(child); + + if (acpi_get_device(dinfo->ad_handle) == child) + AcpiDetachData(dinfo->ad_handle, acpi_fake_objhandler); +} + +/* * Handle per-device ivars */ static int @@ -1769,10 +1788,8 @@ acpi_device_scan_cb(ACPI_HANDLE h, UINT32 level, void return (status); /* Remove the old child and its connection to the handle. */ - if (old_dev != NULL) { + if (old_dev != NULL) device_delete_child(device_get_parent(old_dev), old_dev); - AcpiDetachData(h, acpi_fake_objhandler); - } /* Recreate the handle association if the user created a device. */ if (dev != NULL) @@ -1806,7 +1823,7 @@ acpi_device_scan_children(device_t bus, device_t dev, * Even though ACPI devices are not PCI, we use the PCI approach for setting * device power states since it's close enough to ACPI. */ -static int +int acpi_set_powerstate(device_t child, int state) { ACPI_HANDLE h; @@ -2251,7 +2268,7 @@ acpi_BatteryIsPresent(device_t dev) /* * Returns true if a device has at least one valid device ID. */ -static BOOLEAN +BOOLEAN acpi_has_hid(ACPI_HANDLE h) { ACPI_DEVICE_INFO *devinfo; Modified: stable/12/sys/dev/acpica/acpivar.h ============================================================================== --- stable/12/sys/dev/acpica/acpivar.h Sun Mar 29 23:33:12 2020 (r359430) +++ stable/12/sys/dev/acpica/acpivar.h Sun Mar 29 23:38:55 2020 (r359431) @@ -371,6 +371,7 @@ int acpi_bus_alloc_gas(device_t dev, int *type, int * u_int flags); void acpi_walk_subtables(void *first, void *end, acpi_subtable_handler *handler, void *arg); +BOOLEAN acpi_has_hid(ACPI_HANDLE handle); BOOLEAN acpi_MatchHid(ACPI_HANDLE h, const char *hid); struct acpi_parse_resource_set { @@ -430,6 +431,7 @@ ACPI_STATUS acpi_pwr_wake_enable(ACPI_HANDLE consumer, ACPI_STATUS acpi_pwr_switch_consumer(ACPI_HANDLE consumer, int state); int acpi_device_pwr_for_sleep(device_t bus, device_t dev, int *dstate); +int acpi_set_powerstate(device_t child, int state); /* APM emulation */ void acpi_apm_init(struct acpi_softc *); @@ -464,6 +466,7 @@ int acpi_wakeup_machdep(struct acpi_softc *sc, int st int sleep_result, int intr_enabled); int acpi_table_quirks(int *quirks); int acpi_machdep_quirks(int *quirks); +int acpi_pnpinfo_str(ACPI_HANDLE handle, char *buf, size_t buflen); uint32_t hpet_get_uid(device_t dev); Modified: stable/12/sys/dev/ichiic/ig4_iic.c ============================================================================== --- stable/12/sys/dev/ichiic/ig4_iic.c Sun Mar 29 23:33:12 2020 (r359430) +++ stable/12/sys/dev/ichiic/ig4_iic.c Sun Mar 29 23:38:55 2020 (r359431) @@ -1201,5 +1201,9 @@ ig4iic_dump(ig4iic_softc_t *sc) devclass_t ig4iic_devclass; DRIVER_MODULE(iicbus, ig4iic, iicbus_driver, iicbus_devclass, NULL, NULL); +#ifdef DEV_ACPI +DRIVER_MODULE(acpi_iicbus, ig4iic, acpi_iicbus_driver, iicbus_devclass, NULL, + NULL); +#endif MODULE_DEPEND(ig4iic, iicbus, IICBUS_MINVER, IICBUS_PREFVER, IICBUS_MAXVER); MODULE_VERSION(ig4iic, 1); Copied: stable/12/sys/dev/iicbus/acpi_iicbus.c (from r358820, head/sys/dev/iicbus/acpi_iicbus.c) ============================================================================== --- /dev/null 00:00:00 1970 (empty, because file is newly added) +++ stable/12/sys/dev/iicbus/acpi_iicbus.c Sun Mar 29 23:38:55 2020 (r359431, copy of r358820, head/sys/dev/iicbus/acpi_iicbus.c) @@ -0,0 +1,789 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD + * + * Copyright (c) 2019-2020 Vladimir Kondratyev <wulf@FreeBSD.org> + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include <sys/cdefs.h> +__FBSDID("$FreeBSD$"); + +#include <sys/param.h> +#include <sys/bus.h> +#include <sys/endian.h> +#include <sys/kernel.h> +#include <sys/malloc.h> +#include <sys/module.h> +#include <sys/rman.h> + +#include <machine/resource.h> + +#include <contrib/dev/acpica/include/acpi.h> +#include <contrib/dev/acpica/include/accommon.h> +#include <contrib/dev/acpica/include/amlcode.h> +#include <dev/acpica/acpivar.h> + +#include <dev/iicbus/iiconf.h> +#include <dev/iicbus/iicbus.h> + +#define ACPI_IICBUS_LOCAL_BUFSIZE 32 /* Fits max SMBUS block size */ + +/* + * Make a copy of ACPI_RESOURCE_I2C_SERIALBUS type and replace "pointer to ACPI + * object name string" field with pointer to ACPI object itself. + * This saves us extra strdup()/free() pair on acpi_iicbus_get_i2cres call. + */ +typedef ACPI_RESOURCE_I2C_SERIALBUS ACPI_IICBUS_RESOURCE_I2C_SERIALBUS; +#define ResourceSource_Handle ResourceSource.StringPtr + +/* Hooks for the ACPI CA debugging infrastructure. */ +#define _COMPONENT ACPI_BUS +ACPI_MODULE_NAME("IIC") + +struct gsb_buffer { + UINT8 status; + UINT8 len; + UINT8 data[]; +} __packed; + +struct acpi_iicbus_softc { + struct iicbus_softc super_sc; + ACPI_CONNECTION_INFO space_handler_info; + bool space_handler_installed; +}; + +struct acpi_iicbus_ivars { + struct iicbus_ivar super_ivar; + ACPI_HANDLE handle; +}; + +static int install_space_handler = 0; +TUNABLE_INT("hw.iicbus.enable_acpi_space_handler", &install_space_handler); + +static inline bool +acpi_resource_is_i2c_serialbus(ACPI_RESOURCE *res) +{ + + return (res->Type == ACPI_RESOURCE_TYPE_SERIAL_BUS && + res->Data.CommonSerialBus.Type == ACPI_RESOURCE_SERIAL_TYPE_I2C); +} + +/* + * IICBUS Address space handler + */ +static int +acpi_iicbus_sendb(device_t dev, u_char slave, char byte) +{ + struct iic_msg msgs[] = { + { slave, IIC_M_WR, 1, &byte }, + }; + + return (iicbus_transfer(dev, msgs, nitems(msgs))); +} + +static int +acpi_iicbus_recvb(device_t dev, u_char slave, char *byte) +{ + char buf; + struct iic_msg msgs[] = { + { slave, IIC_M_RD, 1, &buf }, + }; + int error; + + error = iicbus_transfer(dev, msgs, nitems(msgs)); + if (error == 0) + *byte = buf; + + return (error); +} + +static int +acpi_iicbus_write(device_t dev, u_char slave, char cmd, void *buf, + uint16_t buflen) +{ + struct iic_msg msgs[] = { + { slave, IIC_M_WR | IIC_M_NOSTOP, 1, &cmd }, + { slave, IIC_M_WR | IIC_M_NOSTART, buflen, buf }, + }; + + return (iicbus_transfer(dev, msgs, nitems(msgs))); +} + +static int +acpi_iicbus_read(device_t dev, u_char slave, char cmd, void *buf, + uint16_t buflen) +{ + uint8_t local_buffer[ACPI_IICBUS_LOCAL_BUFSIZE]; + struct iic_msg msgs[] = { + { slave, IIC_M_WR | IIC_M_NOSTOP, 1, &cmd }, + { slave, IIC_M_RD, buflen, NULL }, + }; + int error; + + if (buflen <= sizeof(local_buffer)) + msgs[1].buf = local_buffer; + else + msgs[1].buf = malloc(buflen, M_DEVBUF, M_WAITOK); + error = iicbus_transfer(dev, msgs, nitems(msgs)); + if (error == 0) + memcpy(buf, msgs[1].buf, buflen); + if (msgs[1].buf != local_buffer) + free(msgs[1].buf, M_DEVBUF); + + return (error); +} + +static int +acpi_iicbus_bwrite(device_t dev, u_char slave, char cmd, u_char count, char *buf) +{ + uint8_t bytes[2] = { cmd, count }; + struct iic_msg msgs[] = { + { slave, IIC_M_WR | IIC_M_NOSTOP, nitems(bytes), bytes }, + { slave, IIC_M_WR | IIC_M_NOSTART, count, buf }, + }; + + if (count == 0) + return (errno2iic(EINVAL)); + + return (iicbus_transfer(dev, msgs, nitems(msgs))); +} + +static int +acpi_iicbus_bread(device_t dev, u_char slave, char cmd, u_char *count, char *buf) +{ + uint8_t local_buffer[ACPI_IICBUS_LOCAL_BUFSIZE]; + u_char len; + struct iic_msg msgs[] = { + { slave, IIC_M_WR | IIC_M_NOSTOP, 1, &cmd }, + { slave, IIC_M_RD | IIC_M_NOSTOP, 1, &len }, + }; + struct iic_msg block_msg[] = { + { slave, IIC_M_RD | IIC_M_NOSTART, 0, NULL }, + }; + device_t parent = device_get_parent(dev); + int error; + + /* Have to do this because the command is split in two transfers. */ + error = iicbus_request_bus(parent, dev, IIC_WAIT); + if (error == 0) + error = iicbus_transfer(dev, msgs, nitems(msgs)); + if (error == 0) { + /* + * If the slave offers an empty reply, + * read one byte to generate the stop or abort. + */ + if (len == 0) + block_msg[0].len = 1; + else + block_msg[0].len = len; + if (len <= sizeof(local_buffer)) + block_msg[0].buf = local_buffer; + else + block_msg[0].buf = malloc(len, M_DEVBUF, M_WAITOK); + error = iicbus_transfer(dev, block_msg, nitems(block_msg)); + if (len == 0) + error = errno2iic(EBADMSG); + if (error == 0) { + *count = len; + memcpy(buf, block_msg[0].buf, len); + } + if (block_msg[0].buf != local_buffer) + free(block_msg[0].buf, M_DEVBUF); + } + (void)iicbus_release_bus(parent, dev); + return (error); +} + +static ACPI_STATUS +acpi_iicbus_space_handler(UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, + UINT32 BitWidth, UINT64 *Value, void *HandlerContext, void *RegionContext) +{ + struct gsb_buffer *gsb; + struct acpi_iicbus_softc *sc; + device_t dev; + ACPI_CONNECTION_INFO *info; + ACPI_RESOURCE_I2C_SERIALBUS *sb; + ACPI_RESOURCE *res; + ACPI_STATUS s; + int val; + + gsb = (struct gsb_buffer *)Value; + if (gsb == NULL) + return (AE_BAD_PARAMETER); + + info = HandlerContext; + s = AcpiBufferToResource(info->Connection, info->Length, &res); + if (ACPI_FAILURE(s)) + return (s); + + if (!acpi_resource_is_i2c_serialbus(res)) { + s = AE_BAD_PARAMETER; + goto err; + } + + sb = &res->Data.I2cSerialBus; + + /* XXX Ignore 10bit addressing for now */ + if (sb->AccessMode == ACPI_I2C_10BIT_MODE) { + s = AE_BAD_PARAMETER; + goto err; + } + +#define AML_FIELD_ATTRIB_MASK 0x0F +#define AML_FIELD_ATTRIO(attr, io) (((attr) << 16) | (io)) + + Function &= AML_FIELD_ATTRIO(AML_FIELD_ATTRIB_MASK, ACPI_IO_MASK); + sc = __containerof(info, struct acpi_iicbus_softc, space_handler_info); + dev = sc->super_sc.dev; + + switch (Function) { + case AML_FIELD_ATTRIO(AML_FIELD_ATTRIB_SEND_RECEIVE, ACPI_READ): + val = acpi_iicbus_recvb(dev, sb->SlaveAddress, gsb->data); + break; + + case AML_FIELD_ATTRIO(AML_FIELD_ATTRIB_SEND_RECEIVE, ACPI_WRITE): + val = acpi_iicbus_sendb(dev, sb->SlaveAddress, gsb->data[0]); + break; + + case AML_FIELD_ATTRIO(AML_FIELD_ATTRIB_BYTE, ACPI_READ): + val = acpi_iicbus_read(dev, sb->SlaveAddress, Address, + gsb->data, 1); + break; + + case AML_FIELD_ATTRIO(AML_FIELD_ATTRIB_BYTE, ACPI_WRITE): + val = acpi_iicbus_write(dev, sb->SlaveAddress, Address, + gsb->data, 1); + break; + + case AML_FIELD_ATTRIO(AML_FIELD_ATTRIB_WORD, ACPI_READ): + val = acpi_iicbus_read(dev, sb->SlaveAddress, Address, + gsb->data, 2); + break; + + case AML_FIELD_ATTRIO(AML_FIELD_ATTRIB_WORD, ACPI_WRITE): + val = acpi_iicbus_write(dev, sb->SlaveAddress, Address, + gsb->data, 2); + break; + + case AML_FIELD_ATTRIO(AML_FIELD_ATTRIB_BLOCK, ACPI_READ): + val = acpi_iicbus_bread(dev, sb->SlaveAddress, Address, + &gsb->len, gsb->data); + break; + + case AML_FIELD_ATTRIO(AML_FIELD_ATTRIB_BLOCK, ACPI_WRITE): + val = acpi_iicbus_bwrite(dev, sb->SlaveAddress, Address, + gsb->len, gsb->data); + break; + + case AML_FIELD_ATTRIO(AML_FIELD_ATTRIB_BYTES, ACPI_READ): + val = acpi_iicbus_read(dev, sb->SlaveAddress, Address, + gsb->data, info->AccessLength); + break; + + case AML_FIELD_ATTRIO(AML_FIELD_ATTRIB_BYTES, ACPI_WRITE): + val = acpi_iicbus_write(dev, sb->SlaveAddress, Address, + gsb->data, info->AccessLength); + break; + + default: + device_printf(dev, "protocol(0x%04x) is not supported.\n", + Function); + s = AE_BAD_PARAMETER; + goto err; + } + + gsb->status = val; + +err: + ACPI_FREE(res); + + return (s); +} + +static int +acpi_iicbus_install_address_space_handler(struct acpi_iicbus_softc *sc) +{ + ACPI_HANDLE handle; + ACPI_STATUS s; + + handle = acpi_get_handle(device_get_parent(sc->super_sc.dev)); + s = AcpiInstallAddressSpaceHandler(handle, ACPI_ADR_SPACE_GSBUS, + &acpi_iicbus_space_handler, NULL, &sc->space_handler_info); + if (ACPI_FAILURE(s)) { + device_printf(sc->super_sc.dev, + "Failed to install GSBUS Address Space Handler in ACPI\n"); + return (ENXIO); + } + + return (0); +} + +static int +acpi_iicbus_remove_address_space_handler(struct acpi_iicbus_softc *sc) +{ + ACPI_HANDLE handle; + ACPI_STATUS s; + + handle = acpi_get_handle(device_get_parent(sc->super_sc.dev)); + s = AcpiRemoveAddressSpaceHandler(handle, ACPI_ADR_SPACE_GSBUS, + &acpi_iicbus_space_handler); + if (ACPI_FAILURE(s)) { + device_printf(sc->super_sc.dev, + "Failed to remove GSBUS Address Space Handler from ACPI\n"); + return (ENXIO); + } + + return (0); +} + +static ACPI_STATUS +acpi_iicbus_get_i2cres_cb(ACPI_RESOURCE *res, void *context) +{ + ACPI_IICBUS_RESOURCE_I2C_SERIALBUS *sb = context; + ACPI_STATUS status; + ACPI_HANDLE handle; + + if (acpi_resource_is_i2c_serialbus(res)) { + status = AcpiGetHandle(ACPI_ROOT_OBJECT, + res->Data.I2cSerialBus.ResourceSource.StringPtr, &handle); + if (ACPI_FAILURE(status)) + return (status); + memcpy(sb, &res->Data.I2cSerialBus, + sizeof(ACPI_IICBUS_RESOURCE_I2C_SERIALBUS)); + /* + * replace "pointer to ACPI object name string" field + * with pointer to ACPI object itself. + */ + sb->ResourceSource_Handle = handle; + return (AE_CTRL_TERMINATE); + } else if (res->Type == ACPI_RESOURCE_TYPE_END_TAG) + return (AE_NOT_FOUND); + + return (AE_OK); +} + +static ACPI_STATUS +acpi_iicbus_get_i2cres(ACPI_HANDLE handle, ACPI_RESOURCE_I2C_SERIALBUS *sb) +{ + + return (AcpiWalkResources(handle, "_CRS", + acpi_iicbus_get_i2cres_cb, sb)); +} + +static ACPI_STATUS +acpi_iicbus_parse_resources_cb(ACPI_RESOURCE *res, void *context) +{ + device_t dev = context; + struct iicbus_ivar *super_devi = device_get_ivars(dev); + struct resource_list *rl = &super_devi->rl; + int irq, gpio_pin; + + switch(res->Type) { + case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: + if (res->Data.ExtendedIrq.InterruptCount > 0) { + irq = res->Data.ExtendedIrq.Interrupts[0]; + if (bootverbose) + printf(" IRQ: %d\n", irq); + resource_list_add_next(rl, SYS_RES_IRQ, irq, irq, 1); + return (AE_CTRL_TERMINATE); + } + break; + case ACPI_RESOURCE_TYPE_GPIO: + if (res->Data.Gpio.ConnectionType == + ACPI_RESOURCE_GPIO_TYPE_INT) { + /* Not supported by FreeBSD yet */ + gpio_pin = res->Data.Gpio.PinTable[0]; + if (bootverbose) + printf(" GPIO IRQ pin: %d\n", gpio_pin); + return (AE_CTRL_TERMINATE); + } + break; + default: + break; + } + + return (AE_OK); +} + +static ACPI_STATUS +acpi_iicbus_parse_resources(ACPI_HANDLE handle, device_t dev) +{ + + return (AcpiWalkResources(handle, "_CRS", + acpi_iicbus_parse_resources_cb, dev)); +} + +static void +acpi_iicbus_dump_res(device_t dev, ACPI_IICBUS_RESOURCE_I2C_SERIALBUS *sb) +{ + device_printf(dev, "found ACPI child\n"); + printf(" SlaveAddress: 0x%04hx\n", sb->SlaveAddress); + printf(" ConnectionSpeed: %uHz\n", sb->ConnectionSpeed); + printf(" SlaveMode: %s\n", + sb->SlaveMode == ACPI_CONTROLLER_INITIATED ? + "ControllerInitiated" : "DeviceInitiated"); + printf(" AddressingMode: %uBit\n", sb->AccessMode == 0 ? 7 : 10); + printf(" ConnectionSharing: %s\n", sb->ConnectionSharing == 0 ? + "Exclusive" : "Shared"); +} + +static device_t +acpi_iicbus_add_child(device_t dev, u_int order, const char *name, int unit) +{ + + return (iicbus_add_child_common( + dev, order, name, unit, sizeof(struct acpi_iicbus_ivars))); +} + +static ACPI_STATUS +acpi_iicbus_enumerate_child(ACPI_HANDLE handle, UINT32 level, + void *context, void **result) +{ + device_t iicbus, child, acpi_child, acpi0; + struct iicbus_softc *super_sc; + ACPI_IICBUS_RESOURCE_I2C_SERIALBUS sb; + ACPI_STATUS status; + UINT32 sta; + + iicbus = context; + super_sc = device_get_softc(iicbus); + + /* + * If no _STA method or if it failed, then assume that + * the device is present. + */ + if (!ACPI_FAILURE(acpi_GetInteger(handle, "_STA", &sta)) && + !ACPI_DEVICE_PRESENT(sta)) + return (AE_OK); + + if (!acpi_has_hid(handle)) + return (AE_OK); + + /* + * Read "I2C Serial Bus Connection Resource Descriptor" + * described in p.19.6.57 of ACPI specification. + */ + bzero(&sb, sizeof(ACPI_IICBUS_RESOURCE_I2C_SERIALBUS)); + if (ACPI_FAILURE(acpi_iicbus_get_i2cres(handle, &sb)) || + sb.SlaveAddress == 0) + return (AE_OK); + if (sb.ResourceSource_Handle != + acpi_get_handle(device_get_parent(iicbus))) + return (AE_OK); + if (bootverbose) + acpi_iicbus_dump_res(iicbus, &sb); + + /* Find out speed of the slowest slave */ + if (super_sc->bus_freq == 0 || super_sc->bus_freq > sb.ConnectionSpeed) + super_sc->bus_freq = sb.ConnectionSpeed; + + /* Delete existing child of acpi bus */ + acpi_child = acpi_get_device(handle); + if (acpi_child != NULL) { + acpi0 = devclass_get_device(devclass_find("acpi"), 0); + if (device_get_parent(acpi_child) != acpi0) + return (AE_OK); + + if (device_is_attached(acpi_child)) + return (AE_OK); + + if (device_delete_child(acpi0, acpi_child) != 0) + return (AE_OK); + } + + child = BUS_ADD_CHILD(iicbus, 0, NULL, -1); + if (child == NULL) { + device_printf(iicbus, "add child failed\n"); + return (AE_OK); + } + + iicbus_set_addr(child, sb.SlaveAddress); + acpi_set_handle(child, handle); + (void)acpi_iicbus_parse_resources(handle, child); + + /* + * Update ACPI-CA to use the IIC enumerated device_t for this handle. + */ + status = AcpiAttachData(handle, acpi_fake_objhandler, child); + if (ACPI_FAILURE(status)) + printf("WARNING: Unable to attach object data to %s - %s\n", + acpi_name(handle), AcpiFormatException(status)); + + return (AE_OK); +} + +static ACPI_STATUS +acpi_iicbus_enumerate_children(device_t dev) +{ + + return (AcpiWalkNamespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, + ACPI_UINT32_MAX, acpi_iicbus_enumerate_child, NULL, dev, NULL)); +} + +static void +acpi_iicbus_set_power_children(device_t dev, int state, bool all_children) +{ + device_t *devlist; + int i, numdevs; + + if (device_get_children(dev, &devlist, &numdevs) != 0) + return; + + for (i = 0; i < numdevs; i++) + if (all_children || device_is_attached(devlist[i]) != 0) + acpi_set_powerstate(devlist[i], state); + + free(devlist, M_TEMP); +} + +static int +acpi_iicbus_probe(device_t dev) +{ + ACPI_HANDLE handle; + device_t controller; + + if (acpi_disabled("iicbus")) + return (ENXIO); + + controller = device_get_parent(dev); + if (controller == NULL) + return (ENXIO); + + handle = acpi_get_handle(controller); + if (handle == NULL) + return (ENXIO); + + return (BUS_PROBE_DEFAULT); +} + +static int +acpi_iicbus_attach(device_t dev) +{ + struct acpi_iicbus_softc *sc = device_get_softc(dev); + int error; + + device_set_desc(dev, "Philips I2C bus (ACPI-hinted)"); + + if (ACPI_FAILURE(acpi_iicbus_enumerate_children(dev))) + device_printf(dev, "children enumeration failed\n"); + + acpi_iicbus_set_power_children(dev, ACPI_STATE_D0, true); + error = iicbus_attach_common(dev, sc->super_sc.bus_freq); + if (error == 0 && install_space_handler != 0 && + acpi_iicbus_install_address_space_handler(sc) == 0) + sc->space_handler_installed = true; + + return (error); +} + +static int +acpi_iicbus_detach(device_t dev) +{ + struct acpi_iicbus_softc *sc = device_get_softc(dev); + + if (sc->space_handler_installed) + acpi_iicbus_remove_address_space_handler(sc); + acpi_iicbus_set_power_children(dev, ACPI_STATE_D3, false); + + return (iicbus_detach(dev)); +} + +static int +acpi_iicbus_suspend(device_t dev) +{ + int error; + + error = bus_generic_suspend(dev); + if (error == 0) + acpi_iicbus_set_power_children(dev, ACPI_STATE_D3, false); + + return (error); +} + +static int +acpi_iicbus_resume(device_t dev) +{ + + acpi_iicbus_set_power_children(dev, ACPI_STATE_D0, false); + + return (bus_generic_resume(dev)); +} + +/* + * If this device is an ACPI child but no one claimed it, attempt + * to power it off. We'll power it back up when a driver is added. + */ +static void +acpi_iicbus_probe_nomatch(device_t bus, device_t child) +{ + + iicbus_probe_nomatch(bus, child); + acpi_set_powerstate(child, ACPI_STATE_D3); +} + +/* + * If a new driver has a chance to probe a child, first power it up. + */ +static void +acpi_iicbus_driver_added(device_t dev, driver_t *driver) +{ + device_t child, *devlist; + int i, numdevs; + + DEVICE_IDENTIFY(driver, dev); + if (device_get_children(dev, &devlist, &numdevs) != 0) + return; + + for (i = 0; i < numdevs; i++) { + child = devlist[i]; + if (device_get_state(child) == DS_NOTPRESENT) { + acpi_set_powerstate(child, ACPI_STATE_D0); + if (device_probe_and_attach(child) != 0) + acpi_set_powerstate(child, ACPI_STATE_D3); + } + } + free(devlist, M_TEMP); +} + +static void +acpi_iicbus_child_deleted(device_t bus, device_t child) +{ + struct acpi_iicbus_ivars *devi = device_get_ivars(child); + + if (acpi_get_device(devi->handle) == child) + AcpiDetachData(devi->handle, acpi_fake_objhandler); +} + +static int +acpi_iicbus_read_ivar(device_t bus, device_t child, int which, uintptr_t *res) +{ + struct acpi_iicbus_ivars *devi = device_get_ivars(child); + + switch (which) { + case ACPI_IVAR_HANDLE: + *res = (uintptr_t)devi->handle; + break; + default: + return (iicbus_read_ivar(bus, child, which, res)); + } + + return (0); +} + +static int +acpi_iicbus_write_ivar(device_t bus, device_t child, int which, uintptr_t val) +{ + struct acpi_iicbus_ivars *devi = device_get_ivars(child); + + switch (which) { + case ACPI_IVAR_HANDLE: + if (devi->handle != NULL) + return (EINVAL); + devi->handle = (ACPI_HANDLE)val; + break; + default: + return (iicbus_write_ivar(bus, child, which, val)); + } + + return (0); +} + +/* Location hint for devctl(8). Concatenate IIC and ACPI hints. */ +static int +acpi_iicbus_child_location_str(device_t bus, device_t child, + char *buf, size_t buflen) +{ + struct acpi_iicbus_ivars *devi = device_get_ivars(child); + int error; + + /* read IIC location hint string into the buffer. */ + error = iicbus_child_location_str(bus, child, buf, buflen); + if (error != 0) + return (error); + + /* Place ACPI string right after IIC one's terminating NUL. */ + if (devi->handle != NULL && + ((buf[0] != '\0' && strlcat(buf, " ", buflen) >= buflen) || + strlcat(buf, "handle=", buflen) >= buflen || + strlcat(buf, acpi_name(devi->handle), buflen) >= buflen)) + return (EOVERFLOW); + + return (0); +} + +/* PnP information for devctl(8). Concatenate IIC and ACPI info strings. */ +static int +acpi_iicbus_child_pnpinfo_str(device_t bus, device_t child, char *buf, + size_t buflen) +{ + struct acpi_iicbus_ivars *devi = device_get_ivars(child); + size_t acpi_offset; + int error; + + /* read IIC PnP string into the buffer. */ + error = iicbus_child_pnpinfo_str(bus, child, buf, buflen); + if (error != 0) + return (error); + + if (devi->handle == NULL) + return (0); + + /* Place ACPI string right after IIC one's terminating NUL. */ + acpi_offset = strlen(buf); + if (acpi_offset != 0) + acpi_offset++; + error = acpi_pnpinfo_str(devi->handle, buf + acpi_offset, + buflen - acpi_offset); + + /* Coalesce both strings if they are not empty. */ + if (acpi_offset > 0 && acpi_offset < buflen && buf[acpi_offset] != 0) + buf[acpi_offset - 1] = ' '; + + return (error); +} + +static device_method_t acpi_iicbus_methods[] = { + /* Device interface */ + DEVMETHOD(device_probe, acpi_iicbus_probe), + DEVMETHOD(device_attach, acpi_iicbus_attach), + DEVMETHOD(device_detach, acpi_iicbus_detach), + DEVMETHOD(device_suspend, acpi_iicbus_suspend), + DEVMETHOD(device_resume, acpi_iicbus_resume), + + /* Bus interface */ + DEVMETHOD(bus_add_child, acpi_iicbus_add_child), + DEVMETHOD(bus_probe_nomatch, acpi_iicbus_probe_nomatch), + DEVMETHOD(bus_driver_added, acpi_iicbus_driver_added), + DEVMETHOD(bus_child_deleted, acpi_iicbus_child_deleted), + DEVMETHOD(bus_read_ivar, acpi_iicbus_read_ivar), + DEVMETHOD(bus_write_ivar, acpi_iicbus_write_ivar), + DEVMETHOD(bus_child_location_str,acpi_iicbus_child_location_str), + DEVMETHOD(bus_child_pnpinfo_str,acpi_iicbus_child_pnpinfo_str), + + DEVMETHOD_END, +}; + +DEFINE_CLASS_1(iicbus, acpi_iicbus_driver, acpi_iicbus_methods, + sizeof(struct acpi_iicbus_softc), iicbus_driver); +MODULE_VERSION(acpi_iicbus, 1); +MODULE_DEPEND(acpi_iicbus, acpi, 1, 1, 1); Modified: stable/12/sys/dev/iicbus/iicbus.c ============================================================================== --- stable/12/sys/dev/iicbus/iicbus.c Sun Mar 29 23:33:12 2020 (r359430) +++ stable/12/sys/dev/iicbus/iicbus.c Sun Mar 29 23:38:55 2020 (r359431) @@ -89,8 +89,8 @@ iic_probe_device(device_t dev, u_char addr) * We add all the devices which we know about. * The generic attach routine will attach them if they are alive. */ -static int -iicbus_attach(device_t dev) +int +iicbus_attach_common(device_t dev, u_int bus_freq) { #if SCAN_IICBUS unsigned char addr; @@ -100,7 +100,7 @@ iicbus_attach(device_t dev) sc->dev = dev; mtx_init(&sc->lock, "iicbus", NULL, MTX_DEF); - iicbus_init_frequency(dev, 0); + iicbus_init_frequency(dev, bus_freq); iicbus_reset(dev, IIC_FASTEST, 0, NULL); if (resource_int_value(device_get_name(dev), device_get_unit(dev), "strict", &strict) == 0) @@ -131,6 +131,13 @@ iicbus_attach(device_t dev) } static int +iicbus_attach(device_t dev) +{ + + return (iicbus_attach_common(dev, 0)); +} + +int iicbus_detach(device_t dev) { struct iicbus_softc *sc = IICBUS_SOFTC(dev); @@ -158,7 +165,7 @@ iicbus_print_child(device_t dev, device_t child) return (retval); } -static void +void iicbus_probe_nomatch(device_t bus, device_t child) { struct iicbus_ivar *devi = IICBUS_IVAR(child); @@ -166,7 +173,7 @@ iicbus_probe_nomatch(device_t bus, device_t child) device_printf(bus, "<unknown card> at addr %#x\n", devi->addr); } *** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?202003292338.02TNct6k007242>