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 static acpi_status i2c_acpi_lookup_speed(acpi_handle handle, u32 level, 234 void *data, void **return_value) 235 { 236 struct i2c_acpi_lookup *lookup = data; 237 struct acpi_device *adev; 238 239 if (acpi_bus_get_device(handle, &adev)) 240 return AE_OK; 241 242 if (i2c_acpi_do_lookup(adev, lookup)) 243 return AE_OK; 244 245 if (lookup->search_handle != lookup->adapter_handle) 246 return AE_OK; 247 248 if (lookup->speed <= lookup->min_speed) 249 lookup->min_speed = lookup->speed; 250 251 return AE_OK; 252 } 253 254 /** 255 * i2c_acpi_find_bus_speed - find I2C bus speed from ACPI 256 * @dev: The device owning the bus 257 * 258 * Find the I2C bus speed by walking the ACPI namespace for all I2C slaves 259 * devices connected to this bus and use the speed of slowest device. 260 * 261 * Returns the speed in Hz or zero 262 */ 263 u32 i2c_acpi_find_bus_speed(struct device *dev) 264 { 265 struct i2c_acpi_lookup lookup; 266 struct i2c_board_info dummy; 267 acpi_status status; 268 269 if (!has_acpi_companion(dev)) 270 return 0; 271 272 memset(&lookup, 0, sizeof(lookup)); 273 lookup.search_handle = ACPI_HANDLE(dev); 274 lookup.min_speed = UINT_MAX; 275 lookup.info = &dummy; 276 lookup.index = -1; 277 278 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 279 I2C_ACPI_MAX_SCAN_DEPTH, 280 i2c_acpi_lookup_speed, NULL, 281 &lookup, NULL); 282 283 if (ACPI_FAILURE(status)) { 284 dev_warn(dev, "unable to find I2C bus speed from ACPI\n"); 285 return 0; 286 } 287 288 return lookup.min_speed != UINT_MAX ? lookup.min_speed : 0; 289 } 290 EXPORT_SYMBOL_GPL(i2c_acpi_find_bus_speed); 291 292 static int i2c_acpi_match_adapter(struct device *dev, void *data) 293 { 294 struct i2c_adapter *adapter = i2c_verify_adapter(dev); 295 296 if (!adapter) 297 return 0; 298 299 return ACPI_HANDLE(dev) == (acpi_handle)data; 300 } 301 302 static int i2c_acpi_match_device(struct device *dev, void *data) 303 { 304 return ACPI_COMPANION(dev) == data; 305 } 306 307 static struct i2c_adapter *i2c_acpi_find_adapter_by_handle(acpi_handle handle) 308 { 309 struct device *dev; 310 311 dev = bus_find_device(&i2c_bus_type, NULL, handle, 312 i2c_acpi_match_adapter); 313 return dev ? i2c_verify_adapter(dev) : NULL; 314 } 315 316 static struct i2c_client *i2c_acpi_find_client_by_adev(struct acpi_device *adev) 317 { 318 struct device *dev; 319 320 dev = bus_find_device(&i2c_bus_type, NULL, adev, i2c_acpi_match_device); 321 return dev ? i2c_verify_client(dev) : NULL; 322 } 323 324 static int i2c_acpi_notify(struct notifier_block *nb, unsigned long value, 325 void *arg) 326 { 327 struct acpi_device *adev = arg; 328 struct i2c_board_info info; 329 acpi_handle adapter_handle; 330 struct i2c_adapter *adapter; 331 struct i2c_client *client; 332 333 switch (value) { 334 case ACPI_RECONFIG_DEVICE_ADD: 335 if (i2c_acpi_get_info(adev, &info, NULL, &adapter_handle)) 336 break; 337 338 adapter = i2c_acpi_find_adapter_by_handle(adapter_handle); 339 if (!adapter) 340 break; 341 342 i2c_acpi_register_device(adapter, adev, &info); 343 break; 344 case ACPI_RECONFIG_DEVICE_REMOVE: 345 if (!acpi_device_enumerated(adev)) 346 break; 347 348 client = i2c_acpi_find_client_by_adev(adev); 349 if (!client) 350 break; 351 352 i2c_unregister_device(client); 353 put_device(&client->dev); 354 break; 355 } 356 357 return NOTIFY_OK; 358 } 359 360 struct notifier_block i2c_acpi_notifier = { 361 .notifier_call = i2c_acpi_notify, 362 }; 363 364 /** 365 * i2c_acpi_new_device - Create i2c-client for the Nth I2cSerialBus resource 366 * @dev: Device owning the ACPI resources to get the client from 367 * @index: Index of ACPI resource to get 368 * @info: describes the I2C device; note this is modified (addr gets set) 369 * Context: can sleep 370 * 371 * By default the i2c subsys creates an i2c-client for the first I2cSerialBus 372 * resource of an acpi_device, but some acpi_devices have multiple I2cSerialBus 373 * resources, in that case this function can be used to create an i2c-client 374 * for other I2cSerialBus resources in the Current Resource Settings table. 375 * 376 * Also see i2c_new_device, which this function calls to create the i2c-client. 377 * 378 * Returns a pointer to the new i2c-client, or NULL if the adapter is not found. 379 */ 380 struct i2c_client *i2c_acpi_new_device(struct device *dev, int index, 381 struct i2c_board_info *info) 382 { 383 struct i2c_acpi_lookup lookup; 384 struct i2c_adapter *adapter; 385 struct acpi_device *adev; 386 LIST_HEAD(resource_list); 387 int ret; 388 389 adev = ACPI_COMPANION(dev); 390 if (!adev) 391 return NULL; 392 393 memset(&lookup, 0, sizeof(lookup)); 394 lookup.info = info; 395 lookup.device_handle = acpi_device_handle(adev); 396 lookup.index = index; 397 398 ret = acpi_dev_get_resources(adev, &resource_list, 399 i2c_acpi_fill_info, &lookup); 400 acpi_dev_free_resource_list(&resource_list); 401 402 if (ret < 0 || !info->addr) 403 return NULL; 404 405 adapter = i2c_acpi_find_adapter_by_handle(lookup.adapter_handle); 406 if (!adapter) 407 return NULL; 408 409 return i2c_new_device(adapter, info); 410 } 411 EXPORT_SYMBOL_GPL(i2c_acpi_new_device); 412 413 #ifdef CONFIG_ACPI_I2C_OPREGION 414 static int acpi_gsb_i2c_read_bytes(struct i2c_client *client, 415 u8 cmd, u8 *data, u8 data_len) 416 { 417 418 struct i2c_msg msgs[2]; 419 int ret; 420 u8 *buffer; 421 422 buffer = kzalloc(data_len, GFP_KERNEL); 423 if (!buffer) 424 return AE_NO_MEMORY; 425 426 msgs[0].addr = client->addr; 427 msgs[0].flags = client->flags; 428 msgs[0].len = 1; 429 msgs[0].buf = &cmd; 430 431 msgs[1].addr = client->addr; 432 msgs[1].flags = client->flags | I2C_M_RD; 433 msgs[1].len = data_len; 434 msgs[1].buf = buffer; 435 436 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs)); 437 if (ret < 0) 438 dev_err(&client->adapter->dev, "i2c read failed\n"); 439 else 440 memcpy(data, buffer, data_len); 441 442 kfree(buffer); 443 return ret; 444 } 445 446 static int acpi_gsb_i2c_write_bytes(struct i2c_client *client, 447 u8 cmd, u8 *data, u8 data_len) 448 { 449 450 struct i2c_msg msgs[1]; 451 u8 *buffer; 452 int ret = AE_OK; 453 454 buffer = kzalloc(data_len + 1, GFP_KERNEL); 455 if (!buffer) 456 return AE_NO_MEMORY; 457 458 buffer[0] = cmd; 459 memcpy(buffer + 1, data, data_len); 460 461 msgs[0].addr = client->addr; 462 msgs[0].flags = client->flags; 463 msgs[0].len = data_len + 1; 464 msgs[0].buf = buffer; 465 466 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs)); 467 if (ret < 0) 468 dev_err(&client->adapter->dev, "i2c write failed\n"); 469 470 kfree(buffer); 471 return ret; 472 } 473 474 static acpi_status 475 i2c_acpi_space_handler(u32 function, acpi_physical_address command, 476 u32 bits, u64 *value64, 477 void *handler_context, void *region_context) 478 { 479 struct gsb_buffer *gsb = (struct gsb_buffer *)value64; 480 struct i2c_acpi_handler_data *data = handler_context; 481 struct acpi_connection_info *info = &data->info; 482 struct acpi_resource_i2c_serialbus *sb; 483 struct i2c_adapter *adapter = data->adapter; 484 struct i2c_client *client; 485 struct acpi_resource *ares; 486 u32 accessor_type = function >> 16; 487 u8 action = function & ACPI_IO_MASK; 488 acpi_status ret; 489 int status; 490 491 ret = acpi_buffer_to_resource(info->connection, info->length, &ares); 492 if (ACPI_FAILURE(ret)) 493 return ret; 494 495 client = kzalloc(sizeof(*client), GFP_KERNEL); 496 if (!client) { 497 ret = AE_NO_MEMORY; 498 goto err; 499 } 500 501 if (!value64 || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) { 502 ret = AE_BAD_PARAMETER; 503 goto err; 504 } 505 506 sb = &ares->data.i2c_serial_bus; 507 if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) { 508 ret = AE_BAD_PARAMETER; 509 goto err; 510 } 511 512 client->adapter = adapter; 513 client->addr = sb->slave_address; 514 515 if (sb->access_mode == ACPI_I2C_10BIT_MODE) 516 client->flags |= I2C_CLIENT_TEN; 517 518 switch (accessor_type) { 519 case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV: 520 if (action == ACPI_READ) { 521 status = i2c_smbus_read_byte(client); 522 if (status >= 0) { 523 gsb->bdata = status; 524 status = 0; 525 } 526 } else { 527 status = i2c_smbus_write_byte(client, gsb->bdata); 528 } 529 break; 530 531 case ACPI_GSB_ACCESS_ATTRIB_BYTE: 532 if (action == ACPI_READ) { 533 status = i2c_smbus_read_byte_data(client, command); 534 if (status >= 0) { 535 gsb->bdata = status; 536 status = 0; 537 } 538 } else { 539 status = i2c_smbus_write_byte_data(client, command, 540 gsb->bdata); 541 } 542 break; 543 544 case ACPI_GSB_ACCESS_ATTRIB_WORD: 545 if (action == ACPI_READ) { 546 status = i2c_smbus_read_word_data(client, command); 547 if (status >= 0) { 548 gsb->wdata = status; 549 status = 0; 550 } 551 } else { 552 status = i2c_smbus_write_word_data(client, command, 553 gsb->wdata); 554 } 555 break; 556 557 case ACPI_GSB_ACCESS_ATTRIB_BLOCK: 558 if (action == ACPI_READ) { 559 status = i2c_smbus_read_block_data(client, command, 560 gsb->data); 561 if (status >= 0) { 562 gsb->len = status; 563 status = 0; 564 } 565 } else { 566 status = i2c_smbus_write_block_data(client, command, 567 gsb->len, gsb->data); 568 } 569 break; 570 571 case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE: 572 if (action == ACPI_READ) { 573 status = acpi_gsb_i2c_read_bytes(client, command, 574 gsb->data, info->access_length); 575 if (status > 0) 576 status = 0; 577 } else { 578 status = acpi_gsb_i2c_write_bytes(client, command, 579 gsb->data, info->access_length); 580 } 581 break; 582 583 default: 584 dev_warn(&adapter->dev, "protocol 0x%02x not supported for client 0x%02x\n", 585 accessor_type, client->addr); 586 ret = AE_BAD_PARAMETER; 587 goto err; 588 } 589 590 gsb->status = status; 591 592 err: 593 kfree(client); 594 ACPI_FREE(ares); 595 return ret; 596 } 597 598 599 int i2c_acpi_install_space_handler(struct i2c_adapter *adapter) 600 { 601 acpi_handle handle; 602 struct i2c_acpi_handler_data *data; 603 acpi_status status; 604 605 if (!adapter->dev.parent) 606 return -ENODEV; 607 608 handle = ACPI_HANDLE(adapter->dev.parent); 609 610 if (!handle) 611 return -ENODEV; 612 613 data = kzalloc(sizeof(struct i2c_acpi_handler_data), 614 GFP_KERNEL); 615 if (!data) 616 return -ENOMEM; 617 618 data->adapter = adapter; 619 status = acpi_bus_attach_private_data(handle, (void *)data); 620 if (ACPI_FAILURE(status)) { 621 kfree(data); 622 return -ENOMEM; 623 } 624 625 status = acpi_install_address_space_handler(handle, 626 ACPI_ADR_SPACE_GSBUS, 627 &i2c_acpi_space_handler, 628 NULL, 629 data); 630 if (ACPI_FAILURE(status)) { 631 dev_err(&adapter->dev, "Error installing i2c space handler\n"); 632 acpi_bus_detach_private_data(handle); 633 kfree(data); 634 return -ENOMEM; 635 } 636 637 acpi_walk_dep_device_list(handle); 638 return 0; 639 } 640 641 void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter) 642 { 643 acpi_handle handle; 644 struct i2c_acpi_handler_data *data; 645 acpi_status status; 646 647 if (!adapter->dev.parent) 648 return; 649 650 handle = ACPI_HANDLE(adapter->dev.parent); 651 652 if (!handle) 653 return; 654 655 acpi_remove_address_space_handler(handle, 656 ACPI_ADR_SPACE_GSBUS, 657 &i2c_acpi_space_handler); 658 659 status = acpi_bus_get_private_data(handle, (void **)&data); 660 if (ACPI_SUCCESS(status)) 661 kfree(data); 662 663 acpi_bus_detach_private_data(handle); 664 } 665 #endif /* CONFIG_ACPI_I2C_OPREGION */ 666