acpi_i2c.c revision 1.18
1 /* $NetBSD: acpi_i2c.c,v 1.18 2024/12/30 11:44:16 jmcneill Exp $ */ 2 3 /*- 4 * Copyright (c) 2017, 2021 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Manuel Bouyer. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include "iic.h" 33 34 #include <sys/cdefs.h> 35 __KERNEL_RCSID(0, "$NetBSD: acpi_i2c.c,v 1.18 2024/12/30 11:44:16 jmcneill Exp $"); 36 37 #include <sys/device.h> 38 39 #include <dev/acpi/acpireg.h> 40 #include <dev/acpi/acpivar.h> 41 #include <dev/acpi/acpi_i2c.h> 42 #include <external/bsd/acpica/dist/include/acinterp.h> 43 #include <external/bsd/acpica/dist/include/amlcode.h> 44 #include <dev/i2c/i2cvar.h> 45 46 #include <sys/kmem.h> 47 48 #define _COMPONENT ACPI_BUS_COMPONENT 49 ACPI_MODULE_NAME ("acpi_i2c") 50 51 struct acpi_i2c_address_space_context { 52 ACPI_CONNECTION_INFO conn_info; /* must be first */ 53 i2c_tag_t tag; 54 }; 55 56 static const struct device_compatible_entry hid_compat_data[] = { 57 { .compat = "PNP0C50" }, 58 DEVICE_COMPAT_EOL 59 }; 60 61 #if NIIC > 0 62 struct acpi_i2c_context { 63 uint16_t i2c_addr; 64 struct acpi_devnode *res_src; 65 }; 66 #endif 67 68 static struct acpi_devnode * 69 acpi_i2c_resource_find_source(ACPI_RESOURCE_SOURCE *rs) 70 { 71 ACPI_STATUS rv; 72 ACPI_HANDLE hdl; 73 struct acpi_devnode *ad; 74 75 if (rs->StringPtr == NULL) { 76 return NULL; 77 } 78 79 rv = AcpiGetHandle(NULL, rs->StringPtr, &hdl); 80 if (ACPI_FAILURE(rv)) { 81 printf("%s: couldn't lookup '%s': %s\n", __func__, 82 rs->StringPtr, AcpiFormatException(rv)); 83 return NULL; 84 } 85 86 SIMPLEQ_FOREACH(ad, &acpi_softc->sc_head, ad_list) { 87 if (ad->ad_handle == hdl) { 88 return ad; 89 } 90 } 91 92 printf("%s: no acpi devnode matching resource source '%s'\n", 93 __func__, rs->StringPtr); 94 return NULL; 95 } 96 97 static ACPI_STATUS 98 acpi_i2c_resource_parse_callback(ACPI_RESOURCE *res, void *context) 99 { 100 struct acpi_i2c_context *i2cc = context; 101 102 switch (res->Type) { 103 case ACPI_RESOURCE_TYPE_END_TAG: 104 break; 105 case ACPI_RESOURCE_TYPE_SERIAL_BUS: 106 switch (res->Data.I2cSerialBus.Type) { 107 case ACPI_RESOURCE_SERIAL_TYPE_I2C: 108 i2cc->i2c_addr = res->Data.I2cSerialBus.SlaveAddress; 109 i2cc->res_src = acpi_i2c_resource_find_source( 110 &res->Data.I2cSerialBus.ResourceSource); 111 break; 112 } 113 break; 114 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: 115 break; 116 default: 117 break; 118 } 119 return_ACPI_STATUS(AE_OK); 120 } 121 122 static void 123 acpi_enter_i2c_device(struct acpi_devnode *ad, prop_array_t array) 124 { 125 prop_dictionary_t dev; 126 struct acpi_i2c_context i2cc; 127 ACPI_STATUS rv; 128 char *clist; 129 size_t clist_size; 130 131 memset(&i2cc, 0, sizeof(i2cc)); 132 rv = AcpiWalkResources(ad->ad_handle, "_CRS", 133 acpi_i2c_resource_parse_callback, &i2cc); 134 if (ACPI_FAILURE(rv)) { 135 return; 136 } 137 if (i2cc.i2c_addr == 0) 138 return; 139 dev = prop_dictionary_create(); 140 if (dev == NULL) { 141 aprint_error("ignoring device %s (no memory)\n", 142 ad->ad_name); 143 return; 144 } 145 clist = acpi_pack_compat_list(ad, &clist_size); 146 if (clist == NULL) { 147 prop_object_release(dev); 148 aprint_error("ignoring device %s (no _HID or _CID)\n", 149 ad->ad_name); 150 return; 151 } 152 prop_dictionary_set_string(dev, "name", ad->ad_name); 153 prop_dictionary_set_uint32(dev, "addr", i2cc.i2c_addr); 154 prop_dictionary_set_uint64(dev, "cookie", (uintptr_t)ad->ad_handle); 155 prop_dictionary_set_uint32(dev, "cookietype", I2C_COOKIE_ACPI); 156 prop_dictionary_set_data(dev, "compatible", clist, clist_size); 157 kmem_free(clist, clist_size); 158 159 prop_array_add(array, dev); 160 prop_object_release(dev); 161 } 162 163 static void 164 acpi_enter_i2chid_devs(device_t dev, struct acpi_devnode *devnode, 165 prop_array_t array) 166 { 167 struct acpi_devnode *ad; 168 169 KASSERT(dev != NULL); 170 171 SIMPLEQ_FOREACH(ad, &acpi_softc->sc_head, ad_list) { 172 struct acpi_attach_args aa = { 173 .aa_node = ad 174 }; 175 struct acpi_i2c_context i2cc; 176 ACPI_STATUS rv; 177 178 if (!acpi_device_present(ad->ad_handle)) 179 continue; 180 if (ad->ad_device != NULL) 181 continue; 182 if (acpi_compatible_match(&aa, hid_compat_data) == 0) 183 continue; 184 185 memset(&i2cc, 0, sizeof(i2cc)); 186 rv = AcpiWalkResources(ad->ad_handle, "_CRS", 187 acpi_i2c_resource_parse_callback, &i2cc); 188 if (ACPI_SUCCESS(rv) && 189 i2cc.i2c_addr != 0 && 190 i2cc.res_src == devnode) { 191 aprint_debug_dev(dev, "claiming %s\n", ad->ad_name); 192 ad->ad_device = dev; 193 acpi_claim_childdevs(dev, ad); 194 acpi_enter_i2c_device(ad, array); 195 } 196 } 197 } 198 199 prop_array_t 200 acpi_enter_i2c_devs(device_t dev, struct acpi_devnode *devnode) 201 { 202 struct acpi_devnode *ad; 203 prop_array_t array = prop_array_create(); 204 205 if (array == NULL) 206 return NULL; 207 208 SIMPLEQ_FOREACH(ad, &devnode->ad_child_head, ad_child_list) { 209 if (ad->ad_devinfo->Type != ACPI_TYPE_DEVICE) 210 continue; 211 if (!acpi_device_present(ad->ad_handle)) 212 continue; 213 acpi_enter_i2c_device(ad, array); 214 } 215 216 if (dev != NULL) { 217 acpi_claim_childdevs(dev, devnode); 218 acpi_enter_i2chid_devs(dev, devnode, array); 219 } 220 221 return array; 222 } 223 224 #if NIIC > 0 225 static ACPI_STATUS 226 acpi_i2c_gsb_init(ACPI_HANDLE region_hdl, UINT32 function, 227 void *handler_ctx, void **region_ctx) 228 { 229 if (function == ACPI_REGION_DEACTIVATE) { 230 *region_ctx = NULL; 231 } else { 232 *region_ctx = region_hdl; 233 } 234 return AE_OK; 235 } 236 237 static ACPI_STATUS 238 acpi_i2c_gsb_handler(UINT32 function, ACPI_PHYSICAL_ADDRESS address, 239 UINT32 bit_width, UINT64 *value, void *handler_ctx, 240 void *region_ctx) 241 { 242 ACPI_OPERAND_OBJECT *region_obj = region_ctx; 243 struct acpi_i2c_address_space_context *context = handler_ctx; 244 UINT8 *buf = ACPI_CAST_PTR(uint8_t, value); 245 ACPI_PHYSICAL_ADDRESS base_address; 246 ACPI_RESOURCE *res; 247 ACPI_STATUS rv; 248 ACPI_CONNECTION_INFO *conn_info = &context->conn_info; 249 i2c_tag_t tag = context->tag; 250 i2c_addr_t i2c_addr; 251 i2c_op_t op; 252 union { 253 uint8_t cmd8; 254 uint16_t cmd16; 255 uint32_t cmd32; 256 } cmd; 257 size_t buflen; 258 size_t cmdlen; 259 bool do_xfer = true; 260 261 if (region_obj->Region.Type != ACPI_TYPE_REGION) { 262 return AE_OK; 263 } 264 265 base_address = region_obj->Region.Address; 266 KASSERT(region_obj->Region.SpaceId == ACPI_ADR_SPACE_GSBUS); 267 268 rv = AcpiBufferToResource(conn_info->Connection, conn_info->Length, 269 &res); 270 if (ACPI_FAILURE(rv)) { 271 return rv; 272 } 273 if (res->Type != ACPI_RESOURCE_TYPE_SERIAL_BUS || 274 res->Data.CommonSerialBus.Type != ACPI_RESOURCE_SERIAL_TYPE_I2C) { 275 return AE_TYPE; 276 } 277 278 i2c_addr = res->Data.I2cSerialBus.SlaveAddress; 279 if ((function & ACPI_IO_MASK) != 0) { 280 op = I2C_OP_WRITE_WITH_STOP; 281 } else { 282 op = I2C_OP_READ_WITH_STOP; 283 } 284 285 #ifdef ACPI_I2C_DEBUG 286 UINT32 length; 287 rv = AcpiExGetProtocolBufferLength(function >> 16, &length); 288 if (ACPI_FAILURE(rv)) { 289 printf("%s AcpiExGetProtocolBufferLength failed: %s\n", 290 __func__, AcpiFormatException(rv)); 291 length = UINT32_MAX; 292 } 293 printf("%s %s: %s Attr %X Addr %.4X BaseAddr %.4X Length %.2X BitWidth %X BufLen %X", 294 __func__, AcpiUtGetRegionName(region_obj->Region.SpaceId), 295 (function & ACPI_IO_MASK) ? "Write" : "Read ", 296 (UINT32) (function >> 16), 297 (UINT32) address, (UINT32) base_address, 298 length, bit_width, buf[1]); 299 printf(" [AccessLength %.2X Connection %p]\n", 300 conn_info->AccessLength, conn_info->Connection); 301 #endif 302 303 switch ((UINT32)(function >> 16)) { 304 case AML_FIELD_ATTRIB_QUICK: 305 cmdlen = 0; 306 buflen = 0; 307 break; 308 case AML_FIELD_ATTRIB_SEND_RECEIVE: 309 cmdlen = 0; 310 buflen = 1; 311 break; 312 case AML_FIELD_ATTRIB_BYTE: 313 cmdlen = bit_width / NBBY; 314 buflen = 1; 315 break; 316 case AML_FIELD_ATTRIB_WORD: 317 cmdlen = bit_width / NBBY; 318 buflen = 2; 319 break; 320 case AML_FIELD_ATTRIB_BYTES: 321 cmdlen = bit_width / NBBY; 322 buflen = buf[1]; 323 break; 324 case AML_FIELD_ATTRIB_BLOCK: 325 cmdlen = bit_width / NBBY; 326 buflen = buf[1]; 327 op |= I2C_OPMASK_BLKMODE; 328 break; 329 case AML_FIELD_ATTRIB_RAW_BYTES: 330 case AML_FIELD_ATTRIB_RAW_PROCESS_BYTES: 331 case AML_FIELD_ATTRIB_PROCESS_CALL: 332 default: 333 cmdlen = 0; 334 do_xfer = false; 335 #ifdef ACPI_I2C_DEBUG 336 printf("field attrib 0x%x not supported\n", 337 (UINT32)(function >> 16)); 338 #endif 339 break; 340 } 341 342 switch (cmdlen) { 343 case 0: 344 case 1: 345 cmd.cmd8 = (uint8_t)(base_address + address); 346 break; 347 case 2: 348 cmd.cmd16 = (uint16_t)(base_address + address); 349 break; 350 case 4: 351 cmd.cmd32 = (uint32_t)(base_address + address); 352 break; 353 default: 354 do_xfer = false; 355 #ifdef ACPI_I2C_DEBUG 356 printf("cmdlen %zu not supported\n", cmdlen); 357 #endif 358 break; 359 } 360 361 if (!do_xfer) { 362 buf[0] = EINVAL; 363 } else { 364 const int flags = I2C_F_POLL; 365 iic_acquire_bus(tag, flags); 366 buf[0] = iic_exec(tag, op, i2c_addr, 367 &cmd, cmdlen, &buf[2], buflen, flags); 368 iic_release_bus(tag, flags); 369 if (buf[0] == 0) { 370 buf[1] = buflen; 371 } 372 #ifdef ACPI_I2C_DEBUG 373 printf("%s iic_exec op %u addr 0x%x len %zu/%zu returned %d\n", 374 __func__, op, res->Data.I2cSerialBus.SlaveAddress, cmdlen, 375 buflen, buf[0]); 376 #endif 377 } 378 379 ACPI_FREE(res); 380 381 return AE_OK; 382 } 383 #endif 384 385 ACPI_STATUS 386 acpi_i2c_register(struct acpi_devnode *devnode, device_t dev, i2c_tag_t tag) 387 { 388 #if NIIC > 0 389 struct acpi_i2c_address_space_context *context; 390 ACPI_STATUS rv; 391 392 context = kmem_zalloc(sizeof(*context), KM_SLEEP); 393 context->tag = tag; 394 395 rv = AcpiInstallAddressSpaceHandler(devnode->ad_handle, 396 ACPI_ADR_SPACE_GSBUS, acpi_i2c_gsb_handler, acpi_i2c_gsb_init, 397 context); 398 if (ACPI_FAILURE(rv)) { 399 aprint_error_dev(dev, 400 "couldn't install address space handler: %s", 401 AcpiFormatException(rv)); 402 } 403 404 return rv; 405 #else 406 return AE_NOT_CONFIGURED; 407 #endif 408 } 409
Indexes created Wed Sep 24 22:09:59 GMT 2025