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