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