153f8f7c5SWolfram Sang /* 253f8f7c5SWolfram Sang * Linux I2C core ACPI support code 353f8f7c5SWolfram Sang * 453f8f7c5SWolfram Sang * Copyright (C) 2014 Intel Corp, Author: Lan Tianyu <tianyu.lan@intel.com> 553f8f7c5SWolfram Sang * 653f8f7c5SWolfram Sang * This program is free software; you can redistribute it and/or modify it 753f8f7c5SWolfram Sang * under the terms of the GNU General Public License as published by the Free 853f8f7c5SWolfram Sang * Software Foundation; either version 2 of the License, or (at your option) 953f8f7c5SWolfram Sang * any later version. 1053f8f7c5SWolfram Sang */ 1153f8f7c5SWolfram Sang 1253f8f7c5SWolfram Sang #include <linux/acpi.h> 1353f8f7c5SWolfram Sang #include <linux/device.h> 1453f8f7c5SWolfram Sang #include <linux/err.h> 1553f8f7c5SWolfram Sang #include <linux/i2c.h> 1653f8f7c5SWolfram Sang #include <linux/list.h> 1753f8f7c5SWolfram Sang #include <linux/module.h> 1853f8f7c5SWolfram Sang #include <linux/slab.h> 1953f8f7c5SWolfram Sang 2053f8f7c5SWolfram Sang #include "i2c-core.h" 2153f8f7c5SWolfram Sang 2253f8f7c5SWolfram Sang struct i2c_acpi_handler_data { 2353f8f7c5SWolfram Sang struct acpi_connection_info info; 2453f8f7c5SWolfram Sang struct i2c_adapter *adapter; 2553f8f7c5SWolfram Sang }; 2653f8f7c5SWolfram Sang 2753f8f7c5SWolfram Sang struct gsb_buffer { 2853f8f7c5SWolfram Sang u8 status; 2953f8f7c5SWolfram Sang u8 len; 3053f8f7c5SWolfram Sang union { 3153f8f7c5SWolfram Sang u16 wdata; 3253f8f7c5SWolfram Sang u8 bdata; 3353f8f7c5SWolfram Sang u8 data[0]; 3453f8f7c5SWolfram Sang }; 3553f8f7c5SWolfram Sang } __packed; 3653f8f7c5SWolfram Sang 3753f8f7c5SWolfram Sang struct i2c_acpi_lookup { 3853f8f7c5SWolfram Sang struct i2c_board_info *info; 3953f8f7c5SWolfram Sang acpi_handle adapter_handle; 4053f8f7c5SWolfram Sang acpi_handle device_handle; 4153f8f7c5SWolfram Sang acpi_handle search_handle; 4253f8f7c5SWolfram Sang int n; 4353f8f7c5SWolfram Sang int index; 4453f8f7c5SWolfram Sang u32 speed; 4553f8f7c5SWolfram Sang u32 min_speed; 4653f8f7c5SWolfram Sang }; 4753f8f7c5SWolfram Sang 4853f8f7c5SWolfram Sang static int i2c_acpi_fill_info(struct acpi_resource *ares, void *data) 4953f8f7c5SWolfram Sang { 5053f8f7c5SWolfram Sang struct i2c_acpi_lookup *lookup = data; 5153f8f7c5SWolfram Sang struct i2c_board_info *info = lookup->info; 5253f8f7c5SWolfram Sang struct acpi_resource_i2c_serialbus *sb; 5353f8f7c5SWolfram Sang acpi_status status; 5453f8f7c5SWolfram Sang 5553f8f7c5SWolfram Sang if (info->addr || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) 5653f8f7c5SWolfram Sang return 1; 5753f8f7c5SWolfram Sang 5853f8f7c5SWolfram Sang sb = &ares->data.i2c_serial_bus; 5953f8f7c5SWolfram Sang if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) 6053f8f7c5SWolfram Sang return 1; 6153f8f7c5SWolfram Sang 6253f8f7c5SWolfram Sang if (lookup->index != -1 && lookup->n++ != lookup->index) 6353f8f7c5SWolfram Sang return 1; 6453f8f7c5SWolfram Sang 6553f8f7c5SWolfram Sang status = acpi_get_handle(lookup->device_handle, 6653f8f7c5SWolfram Sang sb->resource_source.string_ptr, 6753f8f7c5SWolfram Sang &lookup->adapter_handle); 6853f8f7c5SWolfram Sang if (!ACPI_SUCCESS(status)) 6953f8f7c5SWolfram Sang return 1; 7053f8f7c5SWolfram Sang 7153f8f7c5SWolfram Sang info->addr = sb->slave_address; 7253f8f7c5SWolfram Sang lookup->speed = sb->connection_speed; 7353f8f7c5SWolfram Sang if (sb->access_mode == ACPI_I2C_10BIT_MODE) 7453f8f7c5SWolfram Sang info->flags |= I2C_CLIENT_TEN; 7553f8f7c5SWolfram Sang 7653f8f7c5SWolfram Sang return 1; 7753f8f7c5SWolfram Sang } 7853f8f7c5SWolfram Sang 793a4991a9SHans de Goede static const struct acpi_device_id i2c_acpi_ignored_device_ids[] = { 803a4991a9SHans de Goede /* 813a4991a9SHans de Goede * ACPI video acpi_devices, which are handled by the acpi-video driver 823a4991a9SHans de Goede * sometimes contain a SERIAL_TYPE_I2C ACPI resource, ignore these. 833a4991a9SHans de Goede */ 843a4991a9SHans de Goede { ACPI_VIDEO_HID, 0 }, 853a4991a9SHans de Goede {} 863a4991a9SHans de Goede }; 873a4991a9SHans de Goede 8853f8f7c5SWolfram Sang static int i2c_acpi_do_lookup(struct acpi_device *adev, 8953f8f7c5SWolfram Sang struct i2c_acpi_lookup *lookup) 9053f8f7c5SWolfram Sang { 9153f8f7c5SWolfram Sang struct i2c_board_info *info = lookup->info; 9253f8f7c5SWolfram Sang struct list_head resource_list; 9353f8f7c5SWolfram Sang int ret; 9453f8f7c5SWolfram Sang 9553f8f7c5SWolfram Sang if (acpi_bus_get_status(adev) || !adev->status.present || 9653f8f7c5SWolfram Sang acpi_device_enumerated(adev)) 9753f8f7c5SWolfram Sang return -EINVAL; 9853f8f7c5SWolfram Sang 993a4991a9SHans de Goede if (acpi_match_device_ids(adev, i2c_acpi_ignored_device_ids) == 0) 1003a4991a9SHans de Goede return -ENODEV; 1013a4991a9SHans de Goede 10253f8f7c5SWolfram Sang memset(info, 0, sizeof(*info)); 10353f8f7c5SWolfram Sang lookup->device_handle = acpi_device_handle(adev); 10453f8f7c5SWolfram Sang 10553f8f7c5SWolfram Sang /* Look up for I2cSerialBus resource */ 10653f8f7c5SWolfram Sang INIT_LIST_HEAD(&resource_list); 10753f8f7c5SWolfram Sang ret = acpi_dev_get_resources(adev, &resource_list, 10853f8f7c5SWolfram Sang i2c_acpi_fill_info, lookup); 10953f8f7c5SWolfram Sang acpi_dev_free_resource_list(&resource_list); 11053f8f7c5SWolfram Sang 11153f8f7c5SWolfram Sang if (ret < 0 || !info->addr) 11253f8f7c5SWolfram Sang return -EINVAL; 11353f8f7c5SWolfram Sang 11453f8f7c5SWolfram Sang return 0; 11553f8f7c5SWolfram Sang } 11653f8f7c5SWolfram Sang 11753f8f7c5SWolfram Sang static int i2c_acpi_get_info(struct acpi_device *adev, 11853f8f7c5SWolfram Sang struct i2c_board_info *info, 11953f8f7c5SWolfram Sang struct i2c_adapter *adapter, 12053f8f7c5SWolfram Sang acpi_handle *adapter_handle) 12153f8f7c5SWolfram Sang { 12253f8f7c5SWolfram Sang struct list_head resource_list; 12353f8f7c5SWolfram Sang struct resource_entry *entry; 12453f8f7c5SWolfram Sang struct i2c_acpi_lookup lookup; 12553f8f7c5SWolfram Sang int ret; 12653f8f7c5SWolfram Sang 12753f8f7c5SWolfram Sang memset(&lookup, 0, sizeof(lookup)); 12853f8f7c5SWolfram Sang lookup.info = info; 12953f8f7c5SWolfram Sang lookup.index = -1; 13053f8f7c5SWolfram Sang 13153f8f7c5SWolfram Sang ret = i2c_acpi_do_lookup(adev, &lookup); 13253f8f7c5SWolfram Sang if (ret) 13353f8f7c5SWolfram Sang return ret; 13453f8f7c5SWolfram Sang 13553f8f7c5SWolfram Sang if (adapter) { 13653f8f7c5SWolfram Sang /* The adapter must match the one in I2cSerialBus() connector */ 13753f8f7c5SWolfram Sang if (ACPI_HANDLE(&adapter->dev) != lookup.adapter_handle) 13853f8f7c5SWolfram Sang return -ENODEV; 13953f8f7c5SWolfram Sang } else { 14053f8f7c5SWolfram Sang struct acpi_device *adapter_adev; 14153f8f7c5SWolfram Sang 14253f8f7c5SWolfram Sang /* The adapter must be present */ 14353f8f7c5SWolfram Sang if (acpi_bus_get_device(lookup.adapter_handle, &adapter_adev)) 14453f8f7c5SWolfram Sang return -ENODEV; 14553f8f7c5SWolfram Sang if (acpi_bus_get_status(adapter_adev) || 14653f8f7c5SWolfram Sang !adapter_adev->status.present) 14753f8f7c5SWolfram Sang return -ENODEV; 14853f8f7c5SWolfram Sang } 14953f8f7c5SWolfram Sang 15053f8f7c5SWolfram Sang info->fwnode = acpi_fwnode_handle(adev); 15153f8f7c5SWolfram Sang if (adapter_handle) 15253f8f7c5SWolfram Sang *adapter_handle = lookup.adapter_handle; 15353f8f7c5SWolfram Sang 15453f8f7c5SWolfram Sang /* Then fill IRQ number if any */ 15553f8f7c5SWolfram Sang INIT_LIST_HEAD(&resource_list); 15653f8f7c5SWolfram Sang ret = acpi_dev_get_resources(adev, &resource_list, NULL, NULL); 15753f8f7c5SWolfram Sang if (ret < 0) 15853f8f7c5SWolfram Sang return -EINVAL; 15953f8f7c5SWolfram Sang 16053f8f7c5SWolfram Sang resource_list_for_each_entry(entry, &resource_list) { 16153f8f7c5SWolfram Sang if (resource_type(entry->res) == IORESOURCE_IRQ) { 16253f8f7c5SWolfram Sang info->irq = entry->res->start; 16353f8f7c5SWolfram Sang break; 16453f8f7c5SWolfram Sang } 16553f8f7c5SWolfram Sang } 16653f8f7c5SWolfram Sang 16753f8f7c5SWolfram Sang acpi_dev_free_resource_list(&resource_list); 16853f8f7c5SWolfram Sang 16953f8f7c5SWolfram Sang acpi_set_modalias(adev, dev_name(&adev->dev), info->type, 17053f8f7c5SWolfram Sang sizeof(info->type)); 17153f8f7c5SWolfram Sang 17253f8f7c5SWolfram Sang return 0; 17353f8f7c5SWolfram Sang } 17453f8f7c5SWolfram Sang 17553f8f7c5SWolfram Sang static void i2c_acpi_register_device(struct i2c_adapter *adapter, 17653f8f7c5SWolfram Sang struct acpi_device *adev, 17753f8f7c5SWolfram Sang struct i2c_board_info *info) 17853f8f7c5SWolfram Sang { 17953f8f7c5SWolfram Sang adev->power.flags.ignore_parent = true; 18053f8f7c5SWolfram Sang acpi_device_set_enumerated(adev); 18153f8f7c5SWolfram Sang 18253f8f7c5SWolfram Sang if (!i2c_new_device(adapter, info)) { 18353f8f7c5SWolfram Sang adev->power.flags.ignore_parent = false; 18453f8f7c5SWolfram Sang dev_err(&adapter->dev, 18553f8f7c5SWolfram Sang "failed to add I2C device %s from ACPI\n", 18653f8f7c5SWolfram Sang dev_name(&adev->dev)); 18753f8f7c5SWolfram Sang } 18853f8f7c5SWolfram Sang } 18953f8f7c5SWolfram Sang 19053f8f7c5SWolfram Sang static acpi_status i2c_acpi_add_device(acpi_handle handle, u32 level, 19153f8f7c5SWolfram Sang void *data, void **return_value) 19253f8f7c5SWolfram Sang { 19353f8f7c5SWolfram Sang struct i2c_adapter *adapter = data; 19453f8f7c5SWolfram Sang struct acpi_device *adev; 19553f8f7c5SWolfram Sang struct i2c_board_info info; 19653f8f7c5SWolfram Sang 19753f8f7c5SWolfram Sang if (acpi_bus_get_device(handle, &adev)) 19853f8f7c5SWolfram Sang return AE_OK; 19953f8f7c5SWolfram Sang 20053f8f7c5SWolfram Sang if (i2c_acpi_get_info(adev, &info, adapter, NULL)) 20153f8f7c5SWolfram Sang return AE_OK; 20253f8f7c5SWolfram Sang 20353f8f7c5SWolfram Sang i2c_acpi_register_device(adapter, adev, &info); 20453f8f7c5SWolfram Sang 20553f8f7c5SWolfram Sang return AE_OK; 20653f8f7c5SWolfram Sang } 20753f8f7c5SWolfram Sang 20853f8f7c5SWolfram Sang #define I2C_ACPI_MAX_SCAN_DEPTH 32 20953f8f7c5SWolfram Sang 21053f8f7c5SWolfram Sang /** 21153f8f7c5SWolfram Sang * i2c_acpi_register_devices - enumerate I2C slave devices behind adapter 21253f8f7c5SWolfram Sang * @adap: pointer to adapter 21353f8f7c5SWolfram Sang * 21453f8f7c5SWolfram Sang * Enumerate all I2C slave devices behind this adapter by walking the ACPI 21553f8f7c5SWolfram Sang * namespace. When a device is found it will be added to the Linux device 21653f8f7c5SWolfram Sang * model and bound to the corresponding ACPI handle. 21753f8f7c5SWolfram Sang */ 21853f8f7c5SWolfram Sang void i2c_acpi_register_devices(struct i2c_adapter *adap) 21953f8f7c5SWolfram Sang { 22053f8f7c5SWolfram Sang acpi_status status; 22153f8f7c5SWolfram Sang 22253f8f7c5SWolfram Sang if (!has_acpi_companion(&adap->dev)) 22353f8f7c5SWolfram Sang return; 22453f8f7c5SWolfram Sang 22553f8f7c5SWolfram Sang status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 22653f8f7c5SWolfram Sang I2C_ACPI_MAX_SCAN_DEPTH, 22753f8f7c5SWolfram Sang i2c_acpi_add_device, NULL, 22853f8f7c5SWolfram Sang adap, NULL); 22953f8f7c5SWolfram Sang if (ACPI_FAILURE(status)) 23053f8f7c5SWolfram Sang dev_warn(&adap->dev, "failed to enumerate I2C slaves\n"); 23153f8f7c5SWolfram Sang } 23253f8f7c5SWolfram Sang 233c64ffff7SAndy Shevchenko const struct acpi_device_id * 234c64ffff7SAndy Shevchenko i2c_acpi_match_device(const struct acpi_device_id *matches, 235c64ffff7SAndy Shevchenko struct i2c_client *client) 236c64ffff7SAndy Shevchenko { 237c64ffff7SAndy Shevchenko if (!(client && matches)) 238c64ffff7SAndy Shevchenko return NULL; 239c64ffff7SAndy Shevchenko 240c64ffff7SAndy Shevchenko return acpi_match_device(matches, &client->dev); 241c64ffff7SAndy Shevchenko } 242c64ffff7SAndy Shevchenko 24353f8f7c5SWolfram Sang static acpi_status i2c_acpi_lookup_speed(acpi_handle handle, u32 level, 24453f8f7c5SWolfram Sang void *data, void **return_value) 24553f8f7c5SWolfram Sang { 24653f8f7c5SWolfram Sang struct i2c_acpi_lookup *lookup = data; 24753f8f7c5SWolfram Sang struct acpi_device *adev; 24853f8f7c5SWolfram Sang 24953f8f7c5SWolfram Sang if (acpi_bus_get_device(handle, &adev)) 25053f8f7c5SWolfram Sang return AE_OK; 25153f8f7c5SWolfram Sang 25253f8f7c5SWolfram Sang if (i2c_acpi_do_lookup(adev, lookup)) 25353f8f7c5SWolfram Sang return AE_OK; 25453f8f7c5SWolfram Sang 25553f8f7c5SWolfram Sang if (lookup->search_handle != lookup->adapter_handle) 25653f8f7c5SWolfram Sang return AE_OK; 25753f8f7c5SWolfram Sang 25853f8f7c5SWolfram Sang if (lookup->speed <= lookup->min_speed) 25953f8f7c5SWolfram Sang lookup->min_speed = lookup->speed; 26053f8f7c5SWolfram Sang 26153f8f7c5SWolfram Sang return AE_OK; 26253f8f7c5SWolfram Sang } 26353f8f7c5SWolfram Sang 26453f8f7c5SWolfram Sang /** 26553f8f7c5SWolfram Sang * i2c_acpi_find_bus_speed - find I2C bus speed from ACPI 26653f8f7c5SWolfram Sang * @dev: The device owning the bus 26753f8f7c5SWolfram Sang * 26853f8f7c5SWolfram Sang * Find the I2C bus speed by walking the ACPI namespace for all I2C slaves 26953f8f7c5SWolfram Sang * devices connected to this bus and use the speed of slowest device. 27053f8f7c5SWolfram Sang * 27153f8f7c5SWolfram Sang * Returns the speed in Hz or zero 27253f8f7c5SWolfram Sang */ 27353f8f7c5SWolfram Sang u32 i2c_acpi_find_bus_speed(struct device *dev) 27453f8f7c5SWolfram Sang { 27553f8f7c5SWolfram Sang struct i2c_acpi_lookup lookup; 27653f8f7c5SWolfram Sang struct i2c_board_info dummy; 27753f8f7c5SWolfram Sang acpi_status status; 27853f8f7c5SWolfram Sang 27953f8f7c5SWolfram Sang if (!has_acpi_companion(dev)) 28053f8f7c5SWolfram Sang return 0; 28153f8f7c5SWolfram Sang 28253f8f7c5SWolfram Sang memset(&lookup, 0, sizeof(lookup)); 28353f8f7c5SWolfram Sang lookup.search_handle = ACPI_HANDLE(dev); 28453f8f7c5SWolfram Sang lookup.min_speed = UINT_MAX; 28553f8f7c5SWolfram Sang lookup.info = &dummy; 28653f8f7c5SWolfram Sang lookup.index = -1; 28753f8f7c5SWolfram Sang 28853f8f7c5SWolfram Sang status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 28953f8f7c5SWolfram Sang I2C_ACPI_MAX_SCAN_DEPTH, 29053f8f7c5SWolfram Sang i2c_acpi_lookup_speed, NULL, 29153f8f7c5SWolfram Sang &lookup, NULL); 29253f8f7c5SWolfram Sang 29353f8f7c5SWolfram Sang if (ACPI_FAILURE(status)) { 29453f8f7c5SWolfram Sang dev_warn(dev, "unable to find I2C bus speed from ACPI\n"); 29553f8f7c5SWolfram Sang return 0; 29653f8f7c5SWolfram Sang } 29753f8f7c5SWolfram Sang 29853f8f7c5SWolfram Sang return lookup.min_speed != UINT_MAX ? lookup.min_speed : 0; 29953f8f7c5SWolfram Sang } 30053f8f7c5SWolfram Sang EXPORT_SYMBOL_GPL(i2c_acpi_find_bus_speed); 30153f8f7c5SWolfram Sang 302c64ffff7SAndy Shevchenko static int i2c_acpi_find_match_adapter(struct device *dev, void *data) 30353f8f7c5SWolfram Sang { 30453f8f7c5SWolfram Sang struct i2c_adapter *adapter = i2c_verify_adapter(dev); 30553f8f7c5SWolfram Sang 30653f8f7c5SWolfram Sang if (!adapter) 30753f8f7c5SWolfram Sang return 0; 30853f8f7c5SWolfram Sang 30953f8f7c5SWolfram Sang return ACPI_HANDLE(dev) == (acpi_handle)data; 31053f8f7c5SWolfram Sang } 31153f8f7c5SWolfram Sang 312c64ffff7SAndy Shevchenko static int i2c_acpi_find_match_device(struct device *dev, void *data) 31353f8f7c5SWolfram Sang { 31453f8f7c5SWolfram Sang return ACPI_COMPANION(dev) == data; 31553f8f7c5SWolfram Sang } 31653f8f7c5SWolfram Sang 31753f8f7c5SWolfram Sang static struct i2c_adapter *i2c_acpi_find_adapter_by_handle(acpi_handle handle) 31853f8f7c5SWolfram Sang { 31953f8f7c5SWolfram Sang struct device *dev; 32053f8f7c5SWolfram Sang 32153f8f7c5SWolfram Sang dev = bus_find_device(&i2c_bus_type, NULL, handle, 322c64ffff7SAndy Shevchenko i2c_acpi_find_match_adapter); 32353f8f7c5SWolfram Sang return dev ? i2c_verify_adapter(dev) : NULL; 32453f8f7c5SWolfram Sang } 32553f8f7c5SWolfram Sang 32653f8f7c5SWolfram Sang static struct i2c_client *i2c_acpi_find_client_by_adev(struct acpi_device *adev) 32753f8f7c5SWolfram Sang { 32853f8f7c5SWolfram Sang struct device *dev; 32953f8f7c5SWolfram Sang 330c64ffff7SAndy Shevchenko dev = bus_find_device(&i2c_bus_type, NULL, adev, 331c64ffff7SAndy Shevchenko i2c_acpi_find_match_device); 33253f8f7c5SWolfram Sang return dev ? i2c_verify_client(dev) : NULL; 33353f8f7c5SWolfram Sang } 33453f8f7c5SWolfram Sang 33553f8f7c5SWolfram Sang static int i2c_acpi_notify(struct notifier_block *nb, unsigned long value, 33653f8f7c5SWolfram Sang void *arg) 33753f8f7c5SWolfram Sang { 33853f8f7c5SWolfram Sang struct acpi_device *adev = arg; 33953f8f7c5SWolfram Sang struct i2c_board_info info; 34053f8f7c5SWolfram Sang acpi_handle adapter_handle; 34153f8f7c5SWolfram Sang struct i2c_adapter *adapter; 34253f8f7c5SWolfram Sang struct i2c_client *client; 34353f8f7c5SWolfram Sang 34453f8f7c5SWolfram Sang switch (value) { 34553f8f7c5SWolfram Sang case ACPI_RECONFIG_DEVICE_ADD: 34653f8f7c5SWolfram Sang if (i2c_acpi_get_info(adev, &info, NULL, &adapter_handle)) 34753f8f7c5SWolfram Sang break; 34853f8f7c5SWolfram Sang 34953f8f7c5SWolfram Sang adapter = i2c_acpi_find_adapter_by_handle(adapter_handle); 35053f8f7c5SWolfram Sang if (!adapter) 35153f8f7c5SWolfram Sang break; 35253f8f7c5SWolfram Sang 35353f8f7c5SWolfram Sang i2c_acpi_register_device(adapter, adev, &info); 35453f8f7c5SWolfram Sang break; 35553f8f7c5SWolfram Sang case ACPI_RECONFIG_DEVICE_REMOVE: 35653f8f7c5SWolfram Sang if (!acpi_device_enumerated(adev)) 35753f8f7c5SWolfram Sang break; 35853f8f7c5SWolfram Sang 35953f8f7c5SWolfram Sang client = i2c_acpi_find_client_by_adev(adev); 36053f8f7c5SWolfram Sang if (!client) 36153f8f7c5SWolfram Sang break; 36253f8f7c5SWolfram Sang 36353f8f7c5SWolfram Sang i2c_unregister_device(client); 36453f8f7c5SWolfram Sang put_device(&client->dev); 36553f8f7c5SWolfram Sang break; 36653f8f7c5SWolfram Sang } 36753f8f7c5SWolfram Sang 36853f8f7c5SWolfram Sang return NOTIFY_OK; 36953f8f7c5SWolfram Sang } 37053f8f7c5SWolfram Sang 37153f8f7c5SWolfram Sang struct notifier_block i2c_acpi_notifier = { 37253f8f7c5SWolfram Sang .notifier_call = i2c_acpi_notify, 37353f8f7c5SWolfram Sang }; 37453f8f7c5SWolfram Sang 37553f8f7c5SWolfram Sang /** 37653f8f7c5SWolfram Sang * i2c_acpi_new_device - Create i2c-client for the Nth I2cSerialBus resource 37753f8f7c5SWolfram Sang * @dev: Device owning the ACPI resources to get the client from 37853f8f7c5SWolfram Sang * @index: Index of ACPI resource to get 37953f8f7c5SWolfram Sang * @info: describes the I2C device; note this is modified (addr gets set) 38053f8f7c5SWolfram Sang * Context: can sleep 38153f8f7c5SWolfram Sang * 38253f8f7c5SWolfram Sang * By default the i2c subsys creates an i2c-client for the first I2cSerialBus 38353f8f7c5SWolfram Sang * resource of an acpi_device, but some acpi_devices have multiple I2cSerialBus 38453f8f7c5SWolfram Sang * resources, in that case this function can be used to create an i2c-client 38553f8f7c5SWolfram Sang * for other I2cSerialBus resources in the Current Resource Settings table. 38653f8f7c5SWolfram Sang * 38753f8f7c5SWolfram Sang * Also see i2c_new_device, which this function calls to create the i2c-client. 38853f8f7c5SWolfram Sang * 38953f8f7c5SWolfram Sang * Returns a pointer to the new i2c-client, or NULL if the adapter is not found. 39053f8f7c5SWolfram Sang */ 39153f8f7c5SWolfram Sang struct i2c_client *i2c_acpi_new_device(struct device *dev, int index, 39253f8f7c5SWolfram Sang struct i2c_board_info *info) 39353f8f7c5SWolfram Sang { 39453f8f7c5SWolfram Sang struct i2c_acpi_lookup lookup; 39553f8f7c5SWolfram Sang struct i2c_adapter *adapter; 39653f8f7c5SWolfram Sang struct acpi_device *adev; 39753f8f7c5SWolfram Sang LIST_HEAD(resource_list); 39853f8f7c5SWolfram Sang int ret; 39953f8f7c5SWolfram Sang 40053f8f7c5SWolfram Sang adev = ACPI_COMPANION(dev); 40153f8f7c5SWolfram Sang if (!adev) 40253f8f7c5SWolfram Sang return NULL; 40353f8f7c5SWolfram Sang 40453f8f7c5SWolfram Sang memset(&lookup, 0, sizeof(lookup)); 40553f8f7c5SWolfram Sang lookup.info = info; 40653f8f7c5SWolfram Sang lookup.device_handle = acpi_device_handle(adev); 40753f8f7c5SWolfram Sang lookup.index = index; 40853f8f7c5SWolfram Sang 40953f8f7c5SWolfram Sang ret = acpi_dev_get_resources(adev, &resource_list, 41053f8f7c5SWolfram Sang i2c_acpi_fill_info, &lookup); 41153f8f7c5SWolfram Sang acpi_dev_free_resource_list(&resource_list); 41253f8f7c5SWolfram Sang 41353f8f7c5SWolfram Sang if (ret < 0 || !info->addr) 41453f8f7c5SWolfram Sang return NULL; 41553f8f7c5SWolfram Sang 41653f8f7c5SWolfram Sang adapter = i2c_acpi_find_adapter_by_handle(lookup.adapter_handle); 41753f8f7c5SWolfram Sang if (!adapter) 41853f8f7c5SWolfram Sang return NULL; 41953f8f7c5SWolfram Sang 42053f8f7c5SWolfram Sang return i2c_new_device(adapter, info); 42153f8f7c5SWolfram Sang } 42253f8f7c5SWolfram Sang EXPORT_SYMBOL_GPL(i2c_acpi_new_device); 42353f8f7c5SWolfram Sang 42453f8f7c5SWolfram Sang #ifdef CONFIG_ACPI_I2C_OPREGION 42553f8f7c5SWolfram Sang static int acpi_gsb_i2c_read_bytes(struct i2c_client *client, 42653f8f7c5SWolfram Sang u8 cmd, u8 *data, u8 data_len) 42753f8f7c5SWolfram Sang { 42853f8f7c5SWolfram Sang 42953f8f7c5SWolfram Sang struct i2c_msg msgs[2]; 43053f8f7c5SWolfram Sang int ret; 43153f8f7c5SWolfram Sang u8 *buffer; 43253f8f7c5SWolfram Sang 43353f8f7c5SWolfram Sang buffer = kzalloc(data_len, GFP_KERNEL); 43453f8f7c5SWolfram Sang if (!buffer) 43553f8f7c5SWolfram Sang return AE_NO_MEMORY; 43653f8f7c5SWolfram Sang 43753f8f7c5SWolfram Sang msgs[0].addr = client->addr; 43853f8f7c5SWolfram Sang msgs[0].flags = client->flags; 43953f8f7c5SWolfram Sang msgs[0].len = 1; 44053f8f7c5SWolfram Sang msgs[0].buf = &cmd; 44153f8f7c5SWolfram Sang 44253f8f7c5SWolfram Sang msgs[1].addr = client->addr; 44353f8f7c5SWolfram Sang msgs[1].flags = client->flags | I2C_M_RD; 44453f8f7c5SWolfram Sang msgs[1].len = data_len; 44553f8f7c5SWolfram Sang msgs[1].buf = buffer; 44653f8f7c5SWolfram Sang 44753f8f7c5SWolfram Sang ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs)); 4487781edaeSHans de Goede if (ret < 0) { 4497781edaeSHans de Goede /* Getting a NACK is unfortunately normal with some DSTDs */ 4507781edaeSHans de Goede if (ret == -EREMOTEIO) 4517781edaeSHans de Goede dev_dbg(&client->adapter->dev, "i2c read %d bytes from client@%#x starting at reg %#x failed, error: %d\n", 452c8016fa2SHans de Goede data_len, client->addr, cmd, ret); 45353f8f7c5SWolfram Sang else 4547781edaeSHans de Goede dev_err(&client->adapter->dev, "i2c read %d bytes from client@%#x starting at reg %#x failed, error: %d\n", 4557781edaeSHans de Goede data_len, client->addr, cmd, ret); 4560a30446cSHans de Goede /* 2 transfers must have completed successfully */ 4570a30446cSHans de Goede } else if (ret == 2) { 45853f8f7c5SWolfram Sang memcpy(data, buffer, data_len); 4590a30446cSHans de Goede ret = 0; 4600a30446cSHans de Goede } else { 4610a30446cSHans de Goede ret = -EIO; 4627781edaeSHans de Goede } 46353f8f7c5SWolfram Sang 46453f8f7c5SWolfram Sang kfree(buffer); 46553f8f7c5SWolfram Sang return ret; 46653f8f7c5SWolfram Sang } 46753f8f7c5SWolfram Sang 46853f8f7c5SWolfram Sang static int acpi_gsb_i2c_write_bytes(struct i2c_client *client, 46953f8f7c5SWolfram Sang u8 cmd, u8 *data, u8 data_len) 47053f8f7c5SWolfram Sang { 47153f8f7c5SWolfram Sang 47253f8f7c5SWolfram Sang struct i2c_msg msgs[1]; 47353f8f7c5SWolfram Sang u8 *buffer; 47453f8f7c5SWolfram Sang int ret = AE_OK; 47553f8f7c5SWolfram Sang 47653f8f7c5SWolfram Sang buffer = kzalloc(data_len + 1, GFP_KERNEL); 47753f8f7c5SWolfram Sang if (!buffer) 47853f8f7c5SWolfram Sang return AE_NO_MEMORY; 47953f8f7c5SWolfram Sang 48053f8f7c5SWolfram Sang buffer[0] = cmd; 48153f8f7c5SWolfram Sang memcpy(buffer + 1, data, data_len); 48253f8f7c5SWolfram Sang 48353f8f7c5SWolfram Sang msgs[0].addr = client->addr; 48453f8f7c5SWolfram Sang msgs[0].flags = client->flags; 48553f8f7c5SWolfram Sang msgs[0].len = data_len + 1; 48653f8f7c5SWolfram Sang msgs[0].buf = buffer; 48753f8f7c5SWolfram Sang 48853f8f7c5SWolfram Sang ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs)); 48953f8f7c5SWolfram Sang 49053f8f7c5SWolfram Sang kfree(buffer); 491c463a158SHans de Goede 492c463a158SHans de Goede if (ret < 0) { 493c463a158SHans de Goede dev_err(&client->adapter->dev, "i2c write failed: %d\n", ret); 49453f8f7c5SWolfram Sang return ret; 49553f8f7c5SWolfram Sang } 49653f8f7c5SWolfram Sang 497c463a158SHans de Goede /* 1 transfer must have completed successfully */ 498c463a158SHans de Goede return (ret == 1) ? 0 : -EIO; 499c463a158SHans de Goede } 500c463a158SHans de Goede 50153f8f7c5SWolfram Sang static acpi_status 50253f8f7c5SWolfram Sang i2c_acpi_space_handler(u32 function, acpi_physical_address command, 50353f8f7c5SWolfram Sang u32 bits, u64 *value64, 50453f8f7c5SWolfram Sang void *handler_context, void *region_context) 50553f8f7c5SWolfram Sang { 50653f8f7c5SWolfram Sang struct gsb_buffer *gsb = (struct gsb_buffer *)value64; 50753f8f7c5SWolfram Sang struct i2c_acpi_handler_data *data = handler_context; 50853f8f7c5SWolfram Sang struct acpi_connection_info *info = &data->info; 50953f8f7c5SWolfram Sang struct acpi_resource_i2c_serialbus *sb; 51053f8f7c5SWolfram Sang struct i2c_adapter *adapter = data->adapter; 51153f8f7c5SWolfram Sang struct i2c_client *client; 51253f8f7c5SWolfram Sang struct acpi_resource *ares; 51353f8f7c5SWolfram Sang u32 accessor_type = function >> 16; 51453f8f7c5SWolfram Sang u8 action = function & ACPI_IO_MASK; 51553f8f7c5SWolfram Sang acpi_status ret; 51653f8f7c5SWolfram Sang int status; 51753f8f7c5SWolfram Sang 51853f8f7c5SWolfram Sang ret = acpi_buffer_to_resource(info->connection, info->length, &ares); 51953f8f7c5SWolfram Sang if (ACPI_FAILURE(ret)) 52053f8f7c5SWolfram Sang return ret; 52153f8f7c5SWolfram Sang 52253f8f7c5SWolfram Sang client = kzalloc(sizeof(*client), GFP_KERNEL); 52353f8f7c5SWolfram Sang if (!client) { 52453f8f7c5SWolfram Sang ret = AE_NO_MEMORY; 52553f8f7c5SWolfram Sang goto err; 52653f8f7c5SWolfram Sang } 52753f8f7c5SWolfram Sang 52853f8f7c5SWolfram Sang if (!value64 || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) { 52953f8f7c5SWolfram Sang ret = AE_BAD_PARAMETER; 53053f8f7c5SWolfram Sang goto err; 53153f8f7c5SWolfram Sang } 53253f8f7c5SWolfram Sang 53353f8f7c5SWolfram Sang sb = &ares->data.i2c_serial_bus; 53453f8f7c5SWolfram Sang if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) { 53553f8f7c5SWolfram Sang ret = AE_BAD_PARAMETER; 53653f8f7c5SWolfram Sang goto err; 53753f8f7c5SWolfram Sang } 53853f8f7c5SWolfram Sang 53953f8f7c5SWolfram Sang client->adapter = adapter; 54053f8f7c5SWolfram Sang client->addr = sb->slave_address; 54153f8f7c5SWolfram Sang 54253f8f7c5SWolfram Sang if (sb->access_mode == ACPI_I2C_10BIT_MODE) 54353f8f7c5SWolfram Sang client->flags |= I2C_CLIENT_TEN; 54453f8f7c5SWolfram Sang 54553f8f7c5SWolfram Sang switch (accessor_type) { 54653f8f7c5SWolfram Sang case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV: 54753f8f7c5SWolfram Sang if (action == ACPI_READ) { 54853f8f7c5SWolfram Sang status = i2c_smbus_read_byte(client); 54953f8f7c5SWolfram Sang if (status >= 0) { 55053f8f7c5SWolfram Sang gsb->bdata = status; 55153f8f7c5SWolfram Sang status = 0; 55253f8f7c5SWolfram Sang } 55353f8f7c5SWolfram Sang } else { 55453f8f7c5SWolfram Sang status = i2c_smbus_write_byte(client, gsb->bdata); 55553f8f7c5SWolfram Sang } 55653f8f7c5SWolfram Sang break; 55753f8f7c5SWolfram Sang 55853f8f7c5SWolfram Sang case ACPI_GSB_ACCESS_ATTRIB_BYTE: 55953f8f7c5SWolfram Sang if (action == ACPI_READ) { 56053f8f7c5SWolfram Sang status = i2c_smbus_read_byte_data(client, command); 56153f8f7c5SWolfram Sang if (status >= 0) { 56253f8f7c5SWolfram Sang gsb->bdata = status; 56353f8f7c5SWolfram Sang status = 0; 56453f8f7c5SWolfram Sang } 56553f8f7c5SWolfram Sang } else { 56653f8f7c5SWolfram Sang status = i2c_smbus_write_byte_data(client, command, 56753f8f7c5SWolfram Sang gsb->bdata); 56853f8f7c5SWolfram Sang } 56953f8f7c5SWolfram Sang break; 57053f8f7c5SWolfram Sang 57153f8f7c5SWolfram Sang case ACPI_GSB_ACCESS_ATTRIB_WORD: 57253f8f7c5SWolfram Sang if (action == ACPI_READ) { 57353f8f7c5SWolfram Sang status = i2c_smbus_read_word_data(client, command); 57453f8f7c5SWolfram Sang if (status >= 0) { 57553f8f7c5SWolfram Sang gsb->wdata = status; 57653f8f7c5SWolfram Sang status = 0; 57753f8f7c5SWolfram Sang } 57853f8f7c5SWolfram Sang } else { 57953f8f7c5SWolfram Sang status = i2c_smbus_write_word_data(client, command, 58053f8f7c5SWolfram Sang gsb->wdata); 58153f8f7c5SWolfram Sang } 58253f8f7c5SWolfram Sang break; 58353f8f7c5SWolfram Sang 58453f8f7c5SWolfram Sang case ACPI_GSB_ACCESS_ATTRIB_BLOCK: 58553f8f7c5SWolfram Sang if (action == ACPI_READ) { 58653f8f7c5SWolfram Sang status = i2c_smbus_read_block_data(client, command, 58753f8f7c5SWolfram Sang gsb->data); 58853f8f7c5SWolfram Sang if (status >= 0) { 58953f8f7c5SWolfram Sang gsb->len = status; 59053f8f7c5SWolfram Sang status = 0; 59153f8f7c5SWolfram Sang } 59253f8f7c5SWolfram Sang } else { 59353f8f7c5SWolfram Sang status = i2c_smbus_write_block_data(client, command, 59453f8f7c5SWolfram Sang gsb->len, gsb->data); 59553f8f7c5SWolfram Sang } 59653f8f7c5SWolfram Sang break; 59753f8f7c5SWolfram Sang 59853f8f7c5SWolfram Sang case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE: 59953f8f7c5SWolfram Sang if (action == ACPI_READ) { 60053f8f7c5SWolfram Sang status = acpi_gsb_i2c_read_bytes(client, command, 60153f8f7c5SWolfram Sang gsb->data, info->access_length); 60253f8f7c5SWolfram Sang } else { 60353f8f7c5SWolfram Sang status = acpi_gsb_i2c_write_bytes(client, command, 60453f8f7c5SWolfram Sang gsb->data, info->access_length); 60553f8f7c5SWolfram Sang } 60653f8f7c5SWolfram Sang break; 60753f8f7c5SWolfram Sang 60853f8f7c5SWolfram Sang default: 60953f8f7c5SWolfram Sang dev_warn(&adapter->dev, "protocol 0x%02x not supported for client 0x%02x\n", 61053f8f7c5SWolfram Sang accessor_type, client->addr); 61153f8f7c5SWolfram Sang ret = AE_BAD_PARAMETER; 61253f8f7c5SWolfram Sang goto err; 61353f8f7c5SWolfram Sang } 61453f8f7c5SWolfram Sang 61553f8f7c5SWolfram Sang gsb->status = status; 61653f8f7c5SWolfram Sang 61753f8f7c5SWolfram Sang err: 61853f8f7c5SWolfram Sang kfree(client); 61953f8f7c5SWolfram Sang ACPI_FREE(ares); 62053f8f7c5SWolfram Sang return ret; 62153f8f7c5SWolfram Sang } 62253f8f7c5SWolfram Sang 62353f8f7c5SWolfram Sang 62453f8f7c5SWolfram Sang int i2c_acpi_install_space_handler(struct i2c_adapter *adapter) 62553f8f7c5SWolfram Sang { 62653f8f7c5SWolfram Sang acpi_handle handle; 62753f8f7c5SWolfram Sang struct i2c_acpi_handler_data *data; 62853f8f7c5SWolfram Sang acpi_status status; 62953f8f7c5SWolfram Sang 63053f8f7c5SWolfram Sang if (!adapter->dev.parent) 63153f8f7c5SWolfram Sang return -ENODEV; 63253f8f7c5SWolfram Sang 63353f8f7c5SWolfram Sang handle = ACPI_HANDLE(adapter->dev.parent); 63453f8f7c5SWolfram Sang 63553f8f7c5SWolfram Sang if (!handle) 63653f8f7c5SWolfram Sang return -ENODEV; 63753f8f7c5SWolfram Sang 63853f8f7c5SWolfram Sang data = kzalloc(sizeof(struct i2c_acpi_handler_data), 63953f8f7c5SWolfram Sang GFP_KERNEL); 64053f8f7c5SWolfram Sang if (!data) 64153f8f7c5SWolfram Sang return -ENOMEM; 64253f8f7c5SWolfram Sang 64353f8f7c5SWolfram Sang data->adapter = adapter; 64453f8f7c5SWolfram Sang status = acpi_bus_attach_private_data(handle, (void *)data); 64553f8f7c5SWolfram Sang if (ACPI_FAILURE(status)) { 64653f8f7c5SWolfram Sang kfree(data); 64753f8f7c5SWolfram Sang return -ENOMEM; 64853f8f7c5SWolfram Sang } 64953f8f7c5SWolfram Sang 65053f8f7c5SWolfram Sang status = acpi_install_address_space_handler(handle, 65153f8f7c5SWolfram Sang ACPI_ADR_SPACE_GSBUS, 65253f8f7c5SWolfram Sang &i2c_acpi_space_handler, 65353f8f7c5SWolfram Sang NULL, 65453f8f7c5SWolfram Sang data); 65553f8f7c5SWolfram Sang if (ACPI_FAILURE(status)) { 65653f8f7c5SWolfram Sang dev_err(&adapter->dev, "Error installing i2c space handler\n"); 65753f8f7c5SWolfram Sang acpi_bus_detach_private_data(handle); 65853f8f7c5SWolfram Sang kfree(data); 65953f8f7c5SWolfram Sang return -ENOMEM; 66053f8f7c5SWolfram Sang } 66153f8f7c5SWolfram Sang 66253f8f7c5SWolfram Sang acpi_walk_dep_device_list(handle); 66353f8f7c5SWolfram Sang return 0; 66453f8f7c5SWolfram Sang } 66553f8f7c5SWolfram Sang 66653f8f7c5SWolfram Sang void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter) 66753f8f7c5SWolfram Sang { 66853f8f7c5SWolfram Sang acpi_handle handle; 66953f8f7c5SWolfram Sang struct i2c_acpi_handler_data *data; 67053f8f7c5SWolfram Sang acpi_status status; 67153f8f7c5SWolfram Sang 67253f8f7c5SWolfram Sang if (!adapter->dev.parent) 67353f8f7c5SWolfram Sang return; 67453f8f7c5SWolfram Sang 67553f8f7c5SWolfram Sang handle = ACPI_HANDLE(adapter->dev.parent); 67653f8f7c5SWolfram Sang 67753f8f7c5SWolfram Sang if (!handle) 67853f8f7c5SWolfram Sang return; 67953f8f7c5SWolfram Sang 68053f8f7c5SWolfram Sang acpi_remove_address_space_handler(handle, 68153f8f7c5SWolfram Sang ACPI_ADR_SPACE_GSBUS, 68253f8f7c5SWolfram Sang &i2c_acpi_space_handler); 68353f8f7c5SWolfram Sang 68453f8f7c5SWolfram Sang status = acpi_bus_get_private_data(handle, (void **)&data); 68553f8f7c5SWolfram Sang if (ACPI_SUCCESS(status)) 68653f8f7c5SWolfram Sang kfree(data); 68753f8f7c5SWolfram Sang 68853f8f7c5SWolfram Sang acpi_bus_detach_private_data(handle); 68953f8f7c5SWolfram Sang } 69053f8f7c5SWolfram Sang #endif /* CONFIG_ACPI_I2C_OPREGION */ 691