acpi_i2c.c revision 1.17
1 /* $NetBSD: acpi_i2c.c,v 1.17 2024/12/14 12:52:39 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.17 2024/12/14 12:52:39 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 acpi_enter_i2c_device(ad, array); 193 } 194 } 195 } 196 197 prop_array_t 198 acpi_enter_i2c_devs(device_t dev, struct acpi_devnode *devnode) 199 { 200 struct acpi_devnode *ad; 201 prop_array_t array = prop_array_create(); 202 203 if (array == NULL) 204 return NULL; 205 206 SIMPLEQ_FOREACH(ad, &devnode->ad_child_head, ad_child_list) { 207 if (ad->ad_devinfo->Type != ACPI_TYPE_DEVICE) 208 continue; 209 if (!acpi_device_present(ad->ad_handle)) 210 continue; 211 acpi_enter_i2c_device(ad, array); 212 } 213 214 if (dev != NULL) { 215 acpi_claim_childdevs(dev, devnode); 216 acpi_enter_i2chid_devs(dev, devnode, array); 217 } 218 219 return array; 220 } 221 222 #if NIIC > 0 223 static ACPI_STATUS 224 acpi_i2c_gsb_init(ACPI_HANDLE region_hdl, UINT32 function, 225 void *handler_ctx, void **region_ctx) 226 { 227 if (function == ACPI_REGION_DEACTIVATE) { 228 *region_ctx = NULL; 229 } else { 230 *region_ctx = region_hdl; 231 } 232 return AE_OK; 233 } 234 235 static ACPI_STATUS 236 acpi_i2c_gsb_handler(UINT32 function, ACPI_PHYSICAL_ADDRESS address, 237 UINT32 bit_width, UINT64 *value, void *handler_ctx, 238 void *region_ctx) 239 { 240 ACPI_OPERAND_OBJECT *region_obj = region_ctx; 241 struct acpi_i2c_address_space_context *context = handler_ctx; 242 UINT8 *buf = ACPI_CAST_PTR(uint8_t, value); 243 ACPI_PHYSICAL_ADDRESS base_address; 244 ACPI_RESOURCE *res; 245 ACPI_STATUS rv; 246 ACPI_CONNECTION_INFO *conn_info = &context->conn_info; 247 i2c_tag_t tag = context->tag; 248 i2c_addr_t i2c_addr; 249 i2c_op_t op; 250 union { 251 uint8_t cmd8; 252 uint16_t cmd16; 253 uint32_t cmd32; 254 } cmd; 255 size_t buflen; 256 size_t cmdlen; 257 bool do_xfer = true; 258 259 if (region_obj->Region.Type != ACPI_TYPE_REGION) { 260 return AE_OK; 261 } 262 263 base_address = region_obj->Region.Address; 264 KASSERT(region_obj->Region.SpaceId == ACPI_ADR_SPACE_GSBUS); 265 266 rv = AcpiBufferToResource(conn_info->Connection, conn_info->Length, 267 &res); 268 if (ACPI_FAILURE(rv)) { 269 return rv; 270 } 271 if (res->Type != ACPI_RESOURCE_TYPE_SERIAL_BUS || 272 res->Data.CommonSerialBus.Type != ACPI_RESOURCE_SERIAL_TYPE_I2C) { 273 return AE_TYPE; 274 } 275 276 i2c_addr = res->Data.I2cSerialBus.SlaveAddress; 277 if ((function & ACPI_IO_MASK) != 0) { 278 op = I2C_OP_WRITE_WITH_STOP; 279 } else { 280 op = I2C_OP_READ_WITH_STOP; 281 } 282 283 #ifdef ACPI_I2C_DEBUG 284 UINT32 length; 285 rv = AcpiExGetProtocolBufferLength(function >> 16, &length); 286 if (ACPI_FAILURE(rv)) { 287 printf("%s AcpiExGetProtocolBufferLength failed: %s\n", 288 __func__, AcpiFormatException(rv)); 289 length = UINT32_MAX; 290 } 291 printf("%s %s: %s Attr %X Addr %.4X BaseAddr %.4X Length %.2X BitWidth %X BufLen %X", 292 __func__, AcpiUtGetRegionName(region_obj->Region.SpaceId), 293 (function & ACPI_IO_MASK) ? "Write" : "Read ", 294 (UINT32) (function >> 16), 295 (UINT32) address, (UINT32) base_address, 296 length, bit_width, buf[1]); 297 printf(" [AccessLength %.2X Connection %p]\n", 298 conn_info->AccessLength, conn_info->Connection); 299 #endif 300 301 switch ((UINT32)(function >> 16)) { 302 case AML_FIELD_ATTRIB_QUICK: 303 cmdlen = 0; 304 buflen = 0; 305 break; 306 case AML_FIELD_ATTRIB_SEND_RECEIVE: 307 cmdlen = 0; 308 buflen = 1; 309 break; 310 case AML_FIELD_ATTRIB_BYTE: 311 cmdlen = bit_width / NBBY; 312 buflen = 1; 313 break; 314 case AML_FIELD_ATTRIB_WORD: 315 cmdlen = bit_width / NBBY; 316 buflen = 2; 317 break; 318 case AML_FIELD_ATTRIB_BYTES: 319 cmdlen = bit_width / NBBY; 320 buflen = buf[1]; 321 break; 322 case AML_FIELD_ATTRIB_BLOCK: 323 cmdlen = bit_width / NBBY; 324 buflen = buf[1]; 325 op |= I2C_OPMASK_BLKMODE; 326 break; 327 case AML_FIELD_ATTRIB_RAW_BYTES: 328 case AML_FIELD_ATTRIB_RAW_PROCESS_BYTES: 329 case AML_FIELD_ATTRIB_PROCESS_CALL: 330 default: 331 cmdlen = 0; 332 do_xfer = false; 333 #ifdef ACPI_I2C_DEBUG 334 printf("field attrib 0x%x not supported\n", 335 (UINT32)(function >> 16)); 336 #endif 337 break; 338 } 339 340 switch (cmdlen) { 341 case 0: 342 case 1: 343 cmd.cmd8 = (uint8_t)(base_address + address); 344 break; 345 case 2: 346 cmd.cmd16 = (uint16_t)(base_address + address); 347 break; 348 case 4: 349 cmd.cmd32 = (uint32_t)(base_address + address); 350 break; 351 default: 352 do_xfer = false; 353 #ifdef ACPI_I2C_DEBUG 354 printf("cmdlen %zu not supported\n", cmdlen); 355 #endif 356 break; 357 } 358 359 if (!do_xfer) { 360 buf[0] = EINVAL; 361 } else { 362 const int flags = I2C_F_POLL; 363 iic_acquire_bus(tag, flags); 364 buf[0] = iic_exec(tag, op, i2c_addr, 365 &cmd, cmdlen, &buf[2], buflen, flags); 366 iic_release_bus(tag, flags); 367 if (buf[0] == 0) { 368 buf[1] = buflen; 369 } 370 #ifdef ACPI_I2C_DEBUG 371 printf("%s iic_exec op %u addr 0x%x len %zu/%zu returned %d\n", 372 __func__, op, res->Data.I2cSerialBus.SlaveAddress, cmdlen, 373 buflen, buf[0]); 374 #endif 375 } 376 377 ACPI_FREE(res); 378 379 return AE_OK; 380 } 381 #endif 382 383 ACPI_STATUS 384 acpi_i2c_register(struct acpi_devnode *devnode, device_t dev, i2c_tag_t tag) 385 { 386 #if NIIC > 0 387 struct acpi_i2c_address_space_context *context; 388 ACPI_STATUS rv; 389 390 context = kmem_zalloc(sizeof(*context), KM_SLEEP); 391 context->tag = tag; 392 393 rv = AcpiInstallAddressSpaceHandler(devnode->ad_handle, 394 ACPI_ADR_SPACE_GSBUS, acpi_i2c_gsb_handler, acpi_i2c_gsb_init, 395 context); 396 if (ACPI_FAILURE(rv)) { 397 aprint_error_dev(dev, 398 "couldn't install address space handler: %s", 399 AcpiFormatException(rv)); 400 } 401 402 return rv; 403 #else 404 return AE_NOT_CONFIGURED; 405 #endif 406 } 407
Indexes created Mon Sep 22 13:09:51 GMT 2025