drivers/i2c/i2c-acpi.c

   1 /*
   2  * I2C ACPI code
   3  *
   4  * Copyright (C) 2014 Intel Corp
   5  *
   6  * Author: Lan Tianyu <tianyu.lan@intel.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15  * for more details.
  16  */
  17 #define pr_fmt(fmt) "I2C/ACPI : " fmt
  18
  19 #include <linux/kernel.h>
  20 #include <linux/errno.h>
  21 #include <linux/err.h>
  22 #include <linux/i2c.h>
  23 #include <linux/acpi.h>
  24
  25 struct acpi_i2c_handler_data {
  26         struct acpi_connection_info info;
  27         struct i2c_adapter *adapter;
  28 };
  29
  30 struct gsb_buffer {
  31         u8      status;
  32         u8      len;
  33         union {
  34                 u16     wdata;
  35                 u8      bdata;
  36                 u8      data[0];
  37         };
  38 } __packed;
  39
  40 static int acpi_i2c_add_resource(struct acpi_resource *ares, void *data)
  41 {
  42         struct i2c_board_info *info = data;
  43
  44         if (ares->type == ACPI_RESOURCE_TYPE_SERIAL_BUS) {
  45                 struct acpi_resource_i2c_serialbus *sb;
  46
  47                 sb = &ares->data.i2c_serial_bus;
  48                 if (sb->type == ACPI_RESOURCE_SERIAL_TYPE_I2C) {
  49                         info->addr = sb->slave_address;
  50                         if (sb->access_mode == ACPI_I2C_10BIT_MODE)
  51                                 info->flags |= I2C_CLIENT_TEN;
  52                 }
  53         } else if (info->irq < 0) {
  54                 struct resource r;
  55
  56                 if (acpi_dev_resource_interrupt(ares, 0, &r))
  57                         info->irq = r.start;
  58         }
  59
  60         /* Tell the ACPI core to skip this resource */
  61         return 1;
  62 }
  63
  64 static acpi_status acpi_i2c_add_device(acpi_handle handle, u32 level,
  65                                        void *data, void **return_value)
  66 {
  67         struct i2c_adapter *adapter = data;
  68         struct list_head resource_list;
  69         struct i2c_board_info info;
  70         struct acpi_device *adev;
  71         int ret;
  72
  73         if (acpi_bus_get_device(handle, &adev))
  74                 return AE_OK;
  75         if (acpi_bus_get_status(adev) || !adev->status.present)
  76                 return AE_OK;
  77
  78         memset(&info, 0, sizeof(info));
  79         info.acpi_node.companion = adev;
  80         info.irq = -1;
  81
  82         INIT_LIST_HEAD(&resource_list);
  83         ret = acpi_dev_get_resources(adev, &resource_list,
  84                                      acpi_i2c_add_resource, &info);
  85         acpi_dev_free_resource_list(&resource_list);
  86
  87         if (ret < 0 || !info.addr)
  88                 return AE_OK;
  89
  90         adev->power.flags.ignore_parent = true;
  91         strlcpy(info.type, dev_name(&adev->dev), sizeof(info.type));
  92         if (!i2c_new_device(adapter, &info)) {
  93                 adev->power.flags.ignore_parent = false;
  94                 dev_err(&adapter->dev,
  95                         "failed to add I2C device %s from ACPI\n",
  96                         dev_name(&adev->dev));
  97         }
  98
  99         return AE_OK;
 100 }
 101
 102 /**
 103  * acpi_i2c_register_devices - enumerate I2C slave devices behind adapter
 104  * @adap: pointer to adapter
 105  *
 106  * Enumerate all I2C slave devices behind this adapter by walking the ACPI
 107  * namespace. When a device is found it will be added to the Linux device
 108  * model and bound to the corresponding ACPI handle.
 109  */
 110 void acpi_i2c_register_devices(struct i2c_adapter *adap)
 111 {
 112         acpi_handle handle;
 113         acpi_status status;
 114
 115         if (!adap->dev.parent)
 116                 return;
 117
 118         handle = ACPI_HANDLE(adap->dev.parent);
 119         if (!handle)
 120                 return;
 121
 122         status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
 123                                      acpi_i2c_add_device, NULL,
 124                                      adap, NULL);
 125         if (ACPI_FAILURE(status))
 126                 dev_warn(&adap->dev, "failed to enumerate I2C slaves\n");
 127 }
 128
 129 #ifdef CONFIG_ACPI_I2C_OPREGION
 130 static int acpi_gsb_i2c_read_bytes(struct i2c_client *client,
 131                 u8 cmd, u8 *data, u8 data_len)
 132 {
 133
 134         struct i2c_msg msgs[2];
 135         int ret;
 136         u8 *buffer;
 137
 138         buffer = kzalloc(data_len, GFP_KERNEL);
 139         if (!buffer)
 140                 return AE_NO_MEMORY;
 141
 142         msgs[0].addr = client->addr;
 143         msgs[0].flags = client->flags;
 144         msgs[0].len = 1;
 145         msgs[0].buf = &cmd;
 146
 147         msgs[1].addr = client->addr;
 148         msgs[1].flags = client->flags | I2C_M_RD;
 149         msgs[1].len = data_len;
 150         msgs[1].buf = buffer;
 151
 152         ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
 153         if (ret < 0)
 154                 dev_err(&client->adapter->dev, "i2c read failed\n");
 155         else
 156                 memcpy(data, buffer, data_len);
 157
 158         kfree(buffer);
 159         return ret;
 160 }
 161
 162 static int acpi_gsb_i2c_write_bytes(struct i2c_client *client,
 163                 u8 cmd, u8 *data, u8 data_len)
 164 {
 165
 166         struct i2c_msg msgs[1];
 167         u8 *buffer;
 168         int ret = AE_OK;
 169
 170         buffer = kzalloc(data_len + 1, GFP_KERNEL);
 171         if (!buffer)
 172                 return AE_NO_MEMORY;
 173
 174         buffer[0] = cmd;
 175         memcpy(buffer + 1, data, data_len);
 176
 177         msgs[0].addr = client->addr;
 178         msgs[0].flags = client->flags;
 179         msgs[0].len = data_len + 1;
 180         msgs[0].buf = buffer;
 181
 182         ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
 183         if (ret < 0)
 184                 dev_err(&client->adapter->dev, "i2c write failed\n");
 185
 186         kfree(buffer);
 187         return ret;
 188 }
 189
 190 static acpi_status
 191 acpi_i2c_space_handler(u32 function, acpi_physical_address command,
 192                         u32 bits, u64 *value64,
 193                         void *handler_context, void *region_context)
 194 {
 195         struct gsb_buffer *gsb = (struct gsb_buffer *)value64;
 196         struct acpi_i2c_handler_data *data = handler_context;
 197         struct acpi_connection_info *info = &data->info;
 198         struct acpi_resource_i2c_serialbus *sb;
 199         struct i2c_adapter *adapter = data->adapter;
 200         struct i2c_client client;
 201         struct acpi_resource *ares;
 202         u32 accessor_type = function >> 16;
 203         u8 action = function & ACPI_IO_MASK;
 204         acpi_status ret = AE_OK;
 205         int status;
 206
 207         ret = acpi_buffer_to_resource(info->connection, info->length, &ares);
 208         if (ACPI_FAILURE(ret))
 209                 return ret;
 210
 211         if (!value64 || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) {
 212                 ret = AE_BAD_PARAMETER;
 213                 goto err;
 214         }
 215
 216         sb = &ares->data.i2c_serial_bus;
 217         if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) {
 218                 ret = AE_BAD_PARAMETER;
 219                 goto err;
 220         }
 221
 222         memset(&client, 0, sizeof(client));
 223         client.adapter = adapter;
 224         client.addr = sb->slave_address;
 225         client.flags = 0;
 226
 227         if (sb->access_mode == ACPI_I2C_10BIT_MODE)
 228                 client.flags |= I2C_CLIENT_TEN;
 229
 230         switch (accessor_type) {
 231         case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV:
 232                 if (action == ACPI_READ) {
 233                         status = i2c_smbus_read_byte(&client);
 234                         if (status >= 0) {
 235                                 gsb->bdata = status;
 236                                 status = 0;
 237                         }
 238                 } else {
 239                         status = i2c_smbus_write_byte(&client, gsb->bdata);
 240                 }
 241                 break;
 242
 243         case ACPI_GSB_ACCESS_ATTRIB_BYTE:
 244                 if (action == ACPI_READ) {
 245                         status = i2c_smbus_read_byte_data(&client, command);
 246                         if (status >= 0) {
 247                                 gsb->bdata = status;
 248                                 status = 0;
 249                         }
 250                 } else {
 251                         status = i2c_smbus_write_byte_data(&client, command,
 252                                         gsb->bdata);
 253                 }
 254                 break;
 255
 256         case ACPI_GSB_ACCESS_ATTRIB_WORD:
 257                 if (action == ACPI_READ) {
 258                         status = i2c_smbus_read_word_data(&client, command);
 259                         if (status >= 0) {
 260                                 gsb->wdata = status;
 261                                 status = 0;
 262                         }
 263                 } else {
 264                         status = i2c_smbus_write_word_data(&client, command,
 265                                         gsb->wdata);
 266                 }
 267                 break;
 268
 269         case ACPI_GSB_ACCESS_ATTRIB_BLOCK:
 270                 if (action == ACPI_READ) {
 271                         status = i2c_smbus_read_block_data(&client, command,
 272                                         gsb->data);
 273                         if (status >= 0) {
 274                                 gsb->len = status;
 275                                 status = 0;
 276                         }
 277                 } else {
 278                         status = i2c_smbus_write_block_data(&client, command,
 279                                         gsb->len, gsb->data);
 280                 }
 281                 break;
 282
 283         case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE:
 284                 if (action == ACPI_READ) {
 285                         status = acpi_gsb_i2c_read_bytes(&client, command,
 286                                         gsb->data, info->access_length);
 287                         if (status > 0)
 288                                 status = 0;
 289                 } else {
 290                         status = acpi_gsb_i2c_write_bytes(&client, command,
 291                                         gsb->data, info->access_length);
 292                 }
 293                 break;
 294
 295         default:
 296                 pr_info("protocol(0x%02x) is not supported.\n", accessor_type);
 297                 ret = AE_BAD_PARAMETER;
 298                 goto err;
 299         }
 300
 301         gsb->status = status;
 302
 303  err:
 304         ACPI_FREE(ares);
 305         return ret;
 306 }
 307
 308
 309 int acpi_i2c_install_space_handler(struct i2c_adapter *adapter)
 310 {
 311         acpi_handle handle = ACPI_HANDLE(adapter->dev.parent);
 312         struct acpi_i2c_handler_data *data;
 313         acpi_status status;
 314
 315         if (!handle)
 316                 return -ENODEV;
 317
 318         data = kzalloc(sizeof(struct acpi_i2c_handler_data),
 319                             GFP_KERNEL);
 320         if (!data)
 321                 return -ENOMEM;
 322
 323         data->adapter = adapter;
 324         status = acpi_bus_attach_private_data(handle, (void *)data);
 325         if (ACPI_FAILURE(status)) {
 326                 kfree(data);
 327                 return -ENOMEM;
 328         }
 329
 330         status = acpi_install_address_space_handler(handle,
 331                                 ACPI_ADR_SPACE_GSBUS,
 332                                 &acpi_i2c_space_handler,
 333                                 NULL,
 334                                 data);
 335         if (ACPI_FAILURE(status)) {
 336                 dev_err(&adapter->dev, "Error installing i2c space handler\n");
 337                 acpi_bus_detach_private_data(handle);
 338                 kfree(data);
 339                 return -ENOMEM;
 340         }
 341
 342         return 0;
 343 }
 344
 345 void acpi_i2c_remove_space_handler(struct i2c_adapter *adapter)
 346 {
 347         acpi_handle handle = ACPI_HANDLE(adapter->dev.parent);
 348         struct acpi_i2c_handler_data *data;
 349         acpi_status status;
 350
 351         if (!handle)
 352                 return;
 353
 354         acpi_remove_address_space_handler(handle,
 355                                 ACPI_ADR_SPACE_GSBUS,
 356                                 &acpi_i2c_space_handler);
 357
 358         status = acpi_bus_get_private_data(handle, (void **)&data);
 359         if (ACPI_SUCCESS(status))
 360                 kfree(data);
 361
 362         acpi_bus_detach_private_data(handle);
 363 }
 364 #endif