1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Linux I2C core ACPI support code 4 * 5 * Copyright (C) 2014 Intel Corp, Author: Lan Tianyu <tianyu.lan@intel.com> 6 */ 7 8 #include <linux/acpi.h> 9 #include <linux/device.h> 10 #include <linux/err.h> 11 #include <linux/i2c.h> 12 #include <linux/list.h> 13 #include <linux/module.h> 14 #include <linux/slab.h> 15 16 #include "i2c-core.h" 17 18 struct i2c_acpi_handler_data { 19 struct acpi_connection_info info; 20 struct i2c_adapter *adapter; 21 }; 22 23 struct gsb_buffer { 24 u8 status; 25 u8 len; 26 union { 27 u16 wdata; 28 u8 bdata; 29 u8 data[0]; 30 }; 31 } __packed; 32 33 struct i2c_acpi_lookup { 34 struct i2c_board_info *info; 35 acpi_handle adapter_handle; 36 acpi_handle device_handle; 37 acpi_handle search_handle; 38 int n; 39 int index; 40 u32 speed; 41 u32 min_speed; 42 u32 force_speed; 43 }; 44 45 /** 46 * i2c_acpi_get_i2c_resource - Gets I2cSerialBus resource if type matches 47 * @ares: ACPI resource 48 * @i2c: Pointer to I2cSerialBus resource will be returned here 49 * 50 * Checks if the given ACPI resource is of type I2cSerialBus. 51 * In this case, returns a pointer to it to the caller. 52 * 53 * Returns true if resource type is of I2cSerialBus, otherwise false. 54 */ 55 bool i2c_acpi_get_i2c_resource(struct acpi_resource *ares, 56 struct acpi_resource_i2c_serialbus **i2c) 57 { 58 struct acpi_resource_i2c_serialbus *sb; 59 60 if (ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) 61 return false; 62 63 sb = &ares->data.i2c_serial_bus; 64 if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) 65 return false; 66 67 *i2c = sb; 68 return true; 69 } 70 EXPORT_SYMBOL_GPL(i2c_acpi_get_i2c_resource); 71 72 static int i2c_acpi_fill_info(struct acpi_resource *ares, void *data) 73 { 74 struct i2c_acpi_lookup *lookup = data; 75 struct i2c_board_info *info = lookup->info; 76 struct acpi_resource_i2c_serialbus *sb; 77 acpi_status status; 78 79 if (info->addr || !i2c_acpi_get_i2c_resource(ares, &sb)) 80 return 1; 81 82 if (lookup->index != -1 && lookup->n++ != lookup->index) 83 return 1; 84 85 status = acpi_get_handle(lookup->device_handle, 86 sb->resource_source.string_ptr, 87 &lookup->adapter_handle); 88 if (ACPI_FAILURE(status)) 89 return 1; 90 91 info->addr = sb->slave_address; 92 lookup->speed = sb->connection_speed; 93 if (sb->access_mode == ACPI_I2C_10BIT_MODE) 94 info->flags |= I2C_CLIENT_TEN; 95 96 return 1; 97 } 98 99 static const struct acpi_device_id i2c_acpi_ignored_device_ids[] = { 100 /* 101 * ACPI video acpi_devices, which are handled by the acpi-video driver 102 * sometimes contain a SERIAL_TYPE_I2C ACPI resource, ignore these. 103 */ 104 { ACPI_VIDEO_HID, 0 }, 105 {} 106 }; 107 108 static int i2c_acpi_do_lookup(struct acpi_device *adev, 109 struct i2c_acpi_lookup *lookup) 110 { 111 struct i2c_board_info *info = lookup->info; 112 struct list_head resource_list; 113 int ret; 114 115 if (acpi_bus_get_status(adev) || !adev->status.present) 116 return -EINVAL; 117 118 if (acpi_match_device_ids(adev, i2c_acpi_ignored_device_ids) == 0) 119 return -ENODEV; 120 121 memset(info, 0, sizeof(*info)); 122 lookup->device_handle = acpi_device_handle(adev); 123 124 /* Look up for I2cSerialBus resource */ 125 INIT_LIST_HEAD(&resource_list); 126 ret = acpi_dev_get_resources(adev, &resource_list, 127 i2c_acpi_fill_info, lookup); 128 acpi_dev_free_resource_list(&resource_list); 129 130 if (ret < 0 || !info->addr) 131 return -EINVAL; 132 133 return 0; 134 } 135 136 static int i2c_acpi_add_resource(struct acpi_resource *ares, void *data) 137 { 138 int *irq = data; 139 struct resource r; 140 141 if (*irq <= 0 && acpi_dev_resource_interrupt(ares, 0, &r)) 142 *irq = i2c_dev_irq_from_resources(&r, 1); 143 144 return 1; /* No need to add resource to the list */ 145 } 146 147 /** 148 * i2c_acpi_get_irq - get device IRQ number from ACPI 149 * @client: Pointer to the I2C client device 150 * 151 * Find the IRQ number used by a specific client device. 152 * 153 * Return: The IRQ number or an error code. 154 */ 155 int i2c_acpi_get_irq(struct i2c_client *client) 156 { 157 struct acpi_device *adev = ACPI_COMPANION(&client->dev); 158 struct list_head resource_list; 159 int irq = -ENOENT; 160 int ret; 161 162 INIT_LIST_HEAD(&resource_list); 163 164 ret = acpi_dev_get_resources(adev, &resource_list, 165 i2c_acpi_add_resource, &irq); 166 if (ret < 0) 167 return ret; 168 169 acpi_dev_free_resource_list(&resource_list); 170 171 if (irq == -ENOENT) 172 irq = acpi_dev_gpio_irq_get(adev, 0); 173 174 return irq; 175 } 176 177 static int i2c_acpi_get_info(struct acpi_device *adev, 178 struct i2c_board_info *info, 179 struct i2c_adapter *adapter, 180 acpi_handle *adapter_handle) 181 { 182 struct i2c_acpi_lookup lookup; 183 int ret; 184 185 memset(&lookup, 0, sizeof(lookup)); 186 lookup.info = info; 187 lookup.index = -1; 188 189 if (acpi_device_enumerated(adev)) 190 return -EINVAL; 191 192 ret = i2c_acpi_do_lookup(adev, &lookup); 193 if (ret) 194 return ret; 195 196 if (adapter) { 197 /* The adapter must match the one in I2cSerialBus() connector */ 198 if (ACPI_HANDLE(&adapter->dev) != lookup.adapter_handle) 199 return -ENODEV; 200 } else { 201 struct acpi_device *adapter_adev; 202 203 /* The adapter must be present */ 204 if (acpi_bus_get_device(lookup.adapter_handle, &adapter_adev)) 205 return -ENODEV; 206 if (acpi_bus_get_status(adapter_adev) || 207 !adapter_adev->status.present) 208 return -ENODEV; 209 } 210 211 info->fwnode = acpi_fwnode_handle(adev); 212 if (adapter_handle) 213 *adapter_handle = lookup.adapter_handle; 214 215 acpi_set_modalias(adev, dev_name(&adev->dev), info->type, 216 sizeof(info->type)); 217 218 return 0; 219 } 220 221 static void i2c_acpi_register_device(struct i2c_adapter *adapter, 222 struct acpi_device *adev, 223 struct i2c_board_info *info) 224 { 225 adev->power.flags.ignore_parent = true; 226 acpi_device_set_enumerated(adev); 227 228 if (IS_ERR(i2c_new_client_device(adapter, info))) { 229 adev->power.flags.ignore_parent = false; 230 dev_err(&adapter->dev, 231 "failed to add I2C device %s from ACPI\n", 232 dev_name(&adev->dev)); 233 } 234 } 235 236 static acpi_status i2c_acpi_add_device(acpi_handle handle, u32 level, 237 void *data, void **return_value) 238 { 239 struct i2c_adapter *adapter = data; 240 struct acpi_device *adev; 241 struct i2c_board_info info; 242 243 if (acpi_bus_get_device(handle, &adev)) 244 return AE_OK; 245 246 if (i2c_acpi_get_info(adev, &info, adapter, NULL)) 247 return AE_OK; 248 249 i2c_acpi_register_device(adapter, adev, &info); 250 251 return AE_OK; 252 } 253 254 #define I2C_ACPI_MAX_SCAN_DEPTH 32 255 256 /** 257 * i2c_acpi_register_devices - enumerate I2C slave devices behind adapter 258 * @adap: pointer to adapter 259 * 260 * Enumerate all I2C slave devices behind this adapter by walking the ACPI 261 * namespace. When a device is found it will be added to the Linux device 262 * model and bound to the corresponding ACPI handle. 263 */ 264 void i2c_acpi_register_devices(struct i2c_adapter *adap) 265 { 266 acpi_status status; 267 268 if (!has_acpi_companion(&adap->dev)) 269 return; 270 271 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 272 I2C_ACPI_MAX_SCAN_DEPTH, 273 i2c_acpi_add_device, NULL, 274 adap, NULL); 275 if (ACPI_FAILURE(status)) 276 dev_warn(&adap->dev, "failed to enumerate I2C slaves\n"); 277 } 278 279 static const struct acpi_device_id i2c_acpi_force_400khz_device_ids[] = { 280 /* 281 * These Silead touchscreen controllers only work at 400KHz, for 282 * some reason they do not work at 100KHz. On some devices the ACPI 283 * tables list another device at their bus as only being capable 284 * of 100KHz, testing has shown that these other devices work fine 285 * at 400KHz (as can be expected of any recent i2c hw) so we force 286 * the speed of the bus to 400 KHz if a Silead device is present. 287 */ 288 { "MSSL1680", 0 }, 289 {} 290 }; 291 292 static acpi_status i2c_acpi_lookup_speed(acpi_handle handle, u32 level, 293 void *data, void **return_value) 294 { 295 struct i2c_acpi_lookup *lookup = data; 296 struct acpi_device *adev; 297 298 if (acpi_bus_get_device(handle, &adev)) 299 return AE_OK; 300 301 if (i2c_acpi_do_lookup(adev, lookup)) 302 return AE_OK; 303 304 if (lookup->search_handle != lookup->adapter_handle) 305 return AE_OK; 306 307 if (lookup->speed <= lookup->min_speed) 308 lookup->min_speed = lookup->speed; 309 310 if (acpi_match_device_ids(adev, i2c_acpi_force_400khz_device_ids) == 0) 311 lookup->force_speed = I2C_MAX_FAST_MODE_FREQ; 312 313 return AE_OK; 314 } 315 316 /** 317 * i2c_acpi_find_bus_speed - find I2C bus speed from ACPI 318 * @dev: The device owning the bus 319 * 320 * Find the I2C bus speed by walking the ACPI namespace for all I2C slaves 321 * devices connected to this bus and use the speed of slowest device. 322 * 323 * Returns the speed in Hz or zero 324 */ 325 u32 i2c_acpi_find_bus_speed(struct device *dev) 326 { 327 struct i2c_acpi_lookup lookup; 328 struct i2c_board_info dummy; 329 acpi_status status; 330 331 if (!has_acpi_companion(dev)) 332 return 0; 333 334 memset(&lookup, 0, sizeof(lookup)); 335 lookup.search_handle = ACPI_HANDLE(dev); 336 lookup.min_speed = UINT_MAX; 337 lookup.info = &dummy; 338 lookup.index = -1; 339 340 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 341 I2C_ACPI_MAX_SCAN_DEPTH, 342 i2c_acpi_lookup_speed, NULL, 343 &lookup, NULL); 344 345 if (ACPI_FAILURE(status)) { 346 dev_warn(dev, "unable to find I2C bus speed from ACPI\n"); 347 return 0; 348 } 349 350 if (lookup.force_speed) { 351 if (lookup.force_speed != lookup.min_speed) 352 dev_warn(dev, FW_BUG "DSDT uses known not-working I2C bus speed %d, forcing it to %d\n", 353 lookup.min_speed, lookup.force_speed); 354 return lookup.force_speed; 355 } else if (lookup.min_speed != UINT_MAX) { 356 return lookup.min_speed; 357 } else { 358 return 0; 359 } 360 } 361 EXPORT_SYMBOL_GPL(i2c_acpi_find_bus_speed); 362 363 static int i2c_acpi_find_match_adapter(struct device *dev, const void *data) 364 { 365 struct i2c_adapter *adapter = i2c_verify_adapter(dev); 366 367 if (!adapter) 368 return 0; 369 370 return ACPI_HANDLE(dev) == (acpi_handle)data; 371 } 372 373 struct i2c_adapter *i2c_acpi_find_adapter_by_handle(acpi_handle handle) 374 { 375 struct device *dev; 376 377 dev = bus_find_device(&i2c_bus_type, NULL, handle, 378 i2c_acpi_find_match_adapter); 379 380 return dev ? i2c_verify_adapter(dev) : NULL; 381 } 382 EXPORT_SYMBOL_GPL(i2c_acpi_find_adapter_by_handle); 383 384 static struct i2c_client *i2c_acpi_find_client_by_adev(struct acpi_device *adev) 385 { 386 struct device *dev; 387 struct i2c_client *client; 388 389 dev = bus_find_device_by_acpi_dev(&i2c_bus_type, adev); 390 if (!dev) 391 return NULL; 392 393 client = i2c_verify_client(dev); 394 if (!client) 395 put_device(dev); 396 397 return client; 398 } 399 400 static int i2c_acpi_notify(struct notifier_block *nb, unsigned long value, 401 void *arg) 402 { 403 struct acpi_device *adev = arg; 404 struct i2c_board_info info; 405 acpi_handle adapter_handle; 406 struct i2c_adapter *adapter; 407 struct i2c_client *client; 408 409 switch (value) { 410 case ACPI_RECONFIG_DEVICE_ADD: 411 if (i2c_acpi_get_info(adev, &info, NULL, &adapter_handle)) 412 break; 413 414 adapter = i2c_acpi_find_adapter_by_handle(adapter_handle); 415 if (!adapter) 416 break; 417 418 i2c_acpi_register_device(adapter, adev, &info); 419 break; 420 case ACPI_RECONFIG_DEVICE_REMOVE: 421 if (!acpi_device_enumerated(adev)) 422 break; 423 424 client = i2c_acpi_find_client_by_adev(adev); 425 if (!client) 426 break; 427 428 i2c_unregister_device(client); 429 put_device(&client->dev); 430 break; 431 } 432 433 return NOTIFY_OK; 434 } 435 436 struct notifier_block i2c_acpi_notifier = { 437 .notifier_call = i2c_acpi_notify, 438 }; 439 440 /** 441 * i2c_acpi_new_device - Create i2c-client for the Nth I2cSerialBus resource 442 * @dev: Device owning the ACPI resources to get the client from 443 * @index: Index of ACPI resource to get 444 * @info: describes the I2C device; note this is modified (addr gets set) 445 * Context: can sleep 446 * 447 * By default the i2c subsys creates an i2c-client for the first I2cSerialBus 448 * resource of an acpi_device, but some acpi_devices have multiple I2cSerialBus 449 * resources, in that case this function can be used to create an i2c-client 450 * for other I2cSerialBus resources in the Current Resource Settings table. 451 * 452 * Also see i2c_new_client_device, which this function calls to create the 453 * i2c-client. 454 * 455 * Returns a pointer to the new i2c-client, or error pointer in case of failure. 456 * Specifically, -EPROBE_DEFER is returned if the adapter is not found. 457 */ 458 struct i2c_client *i2c_acpi_new_device(struct device *dev, int index, 459 struct i2c_board_info *info) 460 { 461 struct acpi_device *adev = ACPI_COMPANION(dev); 462 struct i2c_acpi_lookup lookup; 463 struct i2c_adapter *adapter; 464 LIST_HEAD(resource_list); 465 int ret; 466 467 memset(&lookup, 0, sizeof(lookup)); 468 lookup.info = info; 469 lookup.device_handle = acpi_device_handle(adev); 470 lookup.index = index; 471 472 ret = acpi_dev_get_resources(adev, &resource_list, 473 i2c_acpi_fill_info, &lookup); 474 if (ret < 0) 475 return ERR_PTR(ret); 476 477 acpi_dev_free_resource_list(&resource_list); 478 479 if (!info->addr) 480 return ERR_PTR(-EADDRNOTAVAIL); 481 482 adapter = i2c_acpi_find_adapter_by_handle(lookup.adapter_handle); 483 if (!adapter) 484 return ERR_PTR(-EPROBE_DEFER); 485 486 return i2c_new_client_device(adapter, info); 487 } 488 EXPORT_SYMBOL_GPL(i2c_acpi_new_device); 489 490 #ifdef CONFIG_ACPI_I2C_OPREGION 491 static int acpi_gsb_i2c_read_bytes(struct i2c_client *client, 492 u8 cmd, u8 *data, u8 data_len) 493 { 494 495 struct i2c_msg msgs[2]; 496 int ret; 497 u8 *buffer; 498 499 buffer = kzalloc(data_len, GFP_KERNEL); 500 if (!buffer) 501 return AE_NO_MEMORY; 502 503 msgs[0].addr = client->addr; 504 msgs[0].flags = client->flags; 505 msgs[0].len = 1; 506 msgs[0].buf = &cmd; 507 508 msgs[1].addr = client->addr; 509 msgs[1].flags = client->flags | I2C_M_RD; 510 msgs[1].len = data_len; 511 msgs[1].buf = buffer; 512 513 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs)); 514 if (ret < 0) { 515 /* Getting a NACK is unfortunately normal with some DSTDs */ 516 if (ret == -EREMOTEIO) 517 dev_dbg(&client->adapter->dev, "i2c read %d bytes from client@%#x starting at reg %#x failed, error: %d\n", 518 data_len, client->addr, cmd, ret); 519 else 520 dev_err(&client->adapter->dev, "i2c read %d bytes from client@%#x starting at reg %#x failed, error: %d\n", 521 data_len, client->addr, cmd, ret); 522 /* 2 transfers must have completed successfully */ 523 } else if (ret == 2) { 524 memcpy(data, buffer, data_len); 525 ret = 0; 526 } else { 527 ret = -EIO; 528 } 529 530 kfree(buffer); 531 return ret; 532 } 533 534 static int acpi_gsb_i2c_write_bytes(struct i2c_client *client, 535 u8 cmd, u8 *data, u8 data_len) 536 { 537 538 struct i2c_msg msgs[1]; 539 u8 *buffer; 540 int ret = AE_OK; 541 542 buffer = kzalloc(data_len + 1, GFP_KERNEL); 543 if (!buffer) 544 return AE_NO_MEMORY; 545 546 buffer[0] = cmd; 547 memcpy(buffer + 1, data, data_len); 548 549 msgs[0].addr = client->addr; 550 msgs[0].flags = client->flags; 551 msgs[0].len = data_len + 1; 552 msgs[0].buf = buffer; 553 554 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs)); 555 556 kfree(buffer); 557 558 if (ret < 0) { 559 dev_err(&client->adapter->dev, "i2c write failed: %d\n", ret); 560 return ret; 561 } 562 563 /* 1 transfer must have completed successfully */ 564 return (ret == 1) ? 0 : -EIO; 565 } 566 567 static acpi_status 568 i2c_acpi_space_handler(u32 function, acpi_physical_address command, 569 u32 bits, u64 *value64, 570 void *handler_context, void *region_context) 571 { 572 struct gsb_buffer *gsb = (struct gsb_buffer *)value64; 573 struct i2c_acpi_handler_data *data = handler_context; 574 struct acpi_connection_info *info = &data->info; 575 struct acpi_resource_i2c_serialbus *sb; 576 struct i2c_adapter *adapter = data->adapter; 577 struct i2c_client *client; 578 struct acpi_resource *ares; 579 u32 accessor_type = function >> 16; 580 u8 action = function & ACPI_IO_MASK; 581 acpi_status ret; 582 int status; 583 584 ret = acpi_buffer_to_resource(info->connection, info->length, &ares); 585 if (ACPI_FAILURE(ret)) 586 return ret; 587 588 client = kzalloc(sizeof(*client), GFP_KERNEL); 589 if (!client) { 590 ret = AE_NO_MEMORY; 591 goto err; 592 } 593 594 if (!value64 || !i2c_acpi_get_i2c_resource(ares, &sb)) { 595 ret = AE_BAD_PARAMETER; 596 goto err; 597 } 598 599 client->adapter = adapter; 600 client->addr = sb->slave_address; 601 602 if (sb->access_mode == ACPI_I2C_10BIT_MODE) 603 client->flags |= I2C_CLIENT_TEN; 604 605 switch (accessor_type) { 606 case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV: 607 if (action == ACPI_READ) { 608 status = i2c_smbus_read_byte(client); 609 if (status >= 0) { 610 gsb->bdata = status; 611 status = 0; 612 } 613 } else { 614 status = i2c_smbus_write_byte(client, gsb->bdata); 615 } 616 break; 617 618 case ACPI_GSB_ACCESS_ATTRIB_BYTE: 619 if (action == ACPI_READ) { 620 status = i2c_smbus_read_byte_data(client, command); 621 if (status >= 0) { 622 gsb->bdata = status; 623 status = 0; 624 } 625 } else { 626 status = i2c_smbus_write_byte_data(client, command, 627 gsb->bdata); 628 } 629 break; 630 631 case ACPI_GSB_ACCESS_ATTRIB_WORD: 632 if (action == ACPI_READ) { 633 status = i2c_smbus_read_word_data(client, command); 634 if (status >= 0) { 635 gsb->wdata = status; 636 status = 0; 637 } 638 } else { 639 status = i2c_smbus_write_word_data(client, command, 640 gsb->wdata); 641 } 642 break; 643 644 case ACPI_GSB_ACCESS_ATTRIB_BLOCK: 645 if (action == ACPI_READ) { 646 status = i2c_smbus_read_block_data(client, command, 647 gsb->data); 648 if (status >= 0) { 649 gsb->len = status; 650 status = 0; 651 } 652 } else { 653 status = i2c_smbus_write_block_data(client, command, 654 gsb->len, gsb->data); 655 } 656 break; 657 658 case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE: 659 if (action == ACPI_READ) { 660 status = acpi_gsb_i2c_read_bytes(client, command, 661 gsb->data, info->access_length); 662 } else { 663 status = acpi_gsb_i2c_write_bytes(client, command, 664 gsb->data, info->access_length); 665 } 666 break; 667 668 default: 669 dev_warn(&adapter->dev, "protocol 0x%02x not supported for client 0x%02x\n", 670 accessor_type, client->addr); 671 ret = AE_BAD_PARAMETER; 672 goto err; 673 } 674 675 gsb->status = status; 676 677 err: 678 kfree(client); 679 ACPI_FREE(ares); 680 return ret; 681 } 682 683 684 int i2c_acpi_install_space_handler(struct i2c_adapter *adapter) 685 { 686 acpi_handle handle; 687 struct i2c_acpi_handler_data *data; 688 acpi_status status; 689 690 if (!adapter->dev.parent) 691 return -ENODEV; 692 693 handle = ACPI_HANDLE(adapter->dev.parent); 694 695 if (!handle) 696 return -ENODEV; 697 698 data = kzalloc(sizeof(struct i2c_acpi_handler_data), 699 GFP_KERNEL); 700 if (!data) 701 return -ENOMEM; 702 703 data->adapter = adapter; 704 status = acpi_bus_attach_private_data(handle, (void *)data); 705 if (ACPI_FAILURE(status)) { 706 kfree(data); 707 return -ENOMEM; 708 } 709 710 status = acpi_install_address_space_handler(handle, 711 ACPI_ADR_SPACE_GSBUS, 712 &i2c_acpi_space_handler, 713 NULL, 714 data); 715 if (ACPI_FAILURE(status)) { 716 dev_err(&adapter->dev, "Error installing i2c space handler\n"); 717 acpi_bus_detach_private_data(handle); 718 kfree(data); 719 return -ENOMEM; 720 } 721 722 acpi_walk_dep_device_list(handle); 723 return 0; 724 } 725 726 void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter) 727 { 728 acpi_handle handle; 729 struct i2c_acpi_handler_data *data; 730 acpi_status status; 731 732 if (!adapter->dev.parent) 733 return; 734 735 handle = ACPI_HANDLE(adapter->dev.parent); 736 737 if (!handle) 738 return; 739 740 acpi_remove_address_space_handler(handle, 741 ACPI_ADR_SPACE_GSBUS, 742 &i2c_acpi_space_handler); 743 744 status = acpi_bus_get_private_data(handle, (void **)&data); 745 if (ACPI_SUCCESS(status)) 746 kfree(data); 747 748 acpi_bus_detach_private_data(handle); 749 } 750 #endif /* CONFIG_ACPI_I2C_OPREGION */ 751