1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Linux I2C core ACPI support code
4  *
5  * Copyright (C) 2014 Intel Corp, Author: Lan Tianyu <tianyu.lan@intel.com>
6  */
7 
8 #include <linux/acpi.h>
9 #include <linux/device.h>
10 #include <linux/err.h>
11 #include <linux/i2c.h>
12 #include <linux/list.h>
13 #include <linux/module.h>
14 #include <linux/slab.h>
15 
16 #include "i2c-core.h"
17 
18 struct i2c_acpi_handler_data {
19 	struct acpi_connection_info info;
20 	struct i2c_adapter *adapter;
21 };
22 
23 struct gsb_buffer {
24 	u8	status;
25 	u8	len;
26 	union {
27 		u16	wdata;
28 		u8	bdata;
29 		DECLARE_FLEX_ARRAY(u8, data);
30 	};
31 } __packed;
32 
33 struct i2c_acpi_lookup {
34 	struct i2c_board_info *info;
35 	acpi_handle adapter_handle;
36 	acpi_handle device_handle;
37 	acpi_handle search_handle;
38 	int n;
39 	int index;
40 	u32 speed;
41 	u32 min_speed;
42 	u32 force_speed;
43 };
44 
45 /**
46  * i2c_acpi_get_i2c_resource - Gets I2cSerialBus resource if type matches
47  * @ares:	ACPI resource
48  * @i2c:	Pointer to I2cSerialBus resource will be returned here
49  *
50  * Checks if the given ACPI resource is of type I2cSerialBus.
51  * In this case, returns a pointer to it to the caller.
52  *
53  * Returns true if resource type is of I2cSerialBus, otherwise false.
54  */
i2c_acpi_get_i2c_resource(struct acpi_resource * ares,struct acpi_resource_i2c_serialbus ** i2c)55 bool i2c_acpi_get_i2c_resource(struct acpi_resource *ares,
56 			       struct acpi_resource_i2c_serialbus **i2c)
57 {
58 	struct acpi_resource_i2c_serialbus *sb;
59 
60 	if (ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS)
61 		return false;
62 
63 	sb = &ares->data.i2c_serial_bus;
64 	if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C)
65 		return false;
66 
67 	*i2c = sb;
68 	return true;
69 }
70 EXPORT_SYMBOL_GPL(i2c_acpi_get_i2c_resource);
71 
i2c_acpi_resource_count(struct acpi_resource * ares,void * data)72 static int i2c_acpi_resource_count(struct acpi_resource *ares, void *data)
73 {
74 	struct acpi_resource_i2c_serialbus *sb;
75 	int *count = data;
76 
77 	if (i2c_acpi_get_i2c_resource(ares, &sb))
78 		*count = *count + 1;
79 
80 	return 1;
81 }
82 
83 /**
84  * i2c_acpi_client_count - Count the number of I2cSerialBus resources
85  * @adev:	ACPI device
86  *
87  * Returns the number of I2cSerialBus resources in the ACPI-device's
88  * resource-list; or a negative error code.
89  */
i2c_acpi_client_count(struct acpi_device * adev)90 int i2c_acpi_client_count(struct acpi_device *adev)
91 {
92 	int ret, count = 0;
93 	LIST_HEAD(r);
94 
95 	ret = acpi_dev_get_resources(adev, &r, i2c_acpi_resource_count, &count);
96 	if (ret < 0)
97 		return ret;
98 
99 	acpi_dev_free_resource_list(&r);
100 	return count;
101 }
102 EXPORT_SYMBOL_GPL(i2c_acpi_client_count);
103 
i2c_acpi_fill_info(struct acpi_resource * ares,void * data)104 static int i2c_acpi_fill_info(struct acpi_resource *ares, void *data)
105 {
106 	struct i2c_acpi_lookup *lookup = data;
107 	struct i2c_board_info *info = lookup->info;
108 	struct acpi_resource_i2c_serialbus *sb;
109 	acpi_status status;
110 
111 	if (info->addr || !i2c_acpi_get_i2c_resource(ares, &sb))
112 		return 1;
113 
114 	if (lookup->index != -1 && lookup->n++ != lookup->index)
115 		return 1;
116 
117 	status = acpi_get_handle(lookup->device_handle,
118 				 sb->resource_source.string_ptr,
119 				 &lookup->adapter_handle);
120 	if (ACPI_FAILURE(status))
121 		return 1;
122 
123 	info->addr = sb->slave_address;
124 	lookup->speed = sb->connection_speed;
125 	if (sb->access_mode == ACPI_I2C_10BIT_MODE)
126 		info->flags |= I2C_CLIENT_TEN;
127 
128 	return 1;
129 }
130 
131 static const struct acpi_device_id i2c_acpi_ignored_device_ids[] = {
132 	/*
133 	 * ACPI video acpi_devices, which are handled by the acpi-video driver
134 	 * sometimes contain a SERIAL_TYPE_I2C ACPI resource, ignore these.
135 	 */
136 	{ ACPI_VIDEO_HID, 0 },
137 	{}
138 };
139 
140 struct i2c_acpi_irq_context {
141 	int irq;
142 	bool wake_capable;
143 };
144 
i2c_acpi_do_lookup(struct acpi_device * adev,struct i2c_acpi_lookup * lookup)145 static int i2c_acpi_do_lookup(struct acpi_device *adev,
146 			      struct i2c_acpi_lookup *lookup)
147 {
148 	struct i2c_board_info *info = lookup->info;
149 	struct list_head resource_list;
150 	int ret;
151 
152 	if (acpi_bus_get_status(adev))
153 		return -EINVAL;
154 
155 	if (!acpi_dev_ready_for_enumeration(adev))
156 		return -ENODEV;
157 
158 	if (acpi_match_device_ids(adev, i2c_acpi_ignored_device_ids) == 0)
159 		return -ENODEV;
160 
161 	memset(info, 0, sizeof(*info));
162 	lookup->device_handle = acpi_device_handle(adev);
163 
164 	/* Look up for I2cSerialBus resource */
165 	INIT_LIST_HEAD(&resource_list);
166 	ret = acpi_dev_get_resources(adev, &resource_list,
167 				     i2c_acpi_fill_info, lookup);
168 	acpi_dev_free_resource_list(&resource_list);
169 
170 	if (ret < 0 || !info->addr)
171 		return -EINVAL;
172 
173 	return 0;
174 }
175 
i2c_acpi_add_irq_resource(struct acpi_resource * ares,void * data)176 static int i2c_acpi_add_irq_resource(struct acpi_resource *ares, void *data)
177 {
178 	struct i2c_acpi_irq_context *irq_ctx = data;
179 	struct resource r;
180 
181 	if (irq_ctx->irq > 0)
182 		return 1;
183 
184 	if (!acpi_dev_resource_interrupt(ares, 0, &r))
185 		return 1;
186 
187 	irq_ctx->irq = i2c_dev_irq_from_resources(&r, 1);
188 	irq_ctx->wake_capable = r.flags & IORESOURCE_IRQ_WAKECAPABLE;
189 
190 	return 1; /* No need to add resource to the list */
191 }
192 
193 /**
194  * i2c_acpi_get_irq - get device IRQ number from ACPI
195  * @client: Pointer to the I2C client device
196  * @wake_capable: Set to true if the IRQ is wake capable
197  *
198  * Find the IRQ number used by a specific client device.
199  *
200  * Return: The IRQ number or an error code.
201  */
i2c_acpi_get_irq(struct i2c_client * client,bool * wake_capable)202 int i2c_acpi_get_irq(struct i2c_client *client, bool *wake_capable)
203 {
204 	struct acpi_device *adev = ACPI_COMPANION(&client->dev);
205 	struct list_head resource_list;
206 	struct i2c_acpi_irq_context irq_ctx = {
207 		.irq = -ENOENT,
208 	};
209 	int ret;
210 
211 	INIT_LIST_HEAD(&resource_list);
212 
213 	ret = acpi_dev_get_resources(adev, &resource_list,
214 				     i2c_acpi_add_irq_resource, &irq_ctx);
215 	if (ret < 0)
216 		return ret;
217 
218 	acpi_dev_free_resource_list(&resource_list);
219 
220 	if (irq_ctx.irq == -ENOENT)
221 		irq_ctx.irq = acpi_dev_gpio_irq_wake_get(adev, 0, &irq_ctx.wake_capable);
222 
223 	if (irq_ctx.irq < 0)
224 		return irq_ctx.irq;
225 
226 	if (wake_capable)
227 		*wake_capable = irq_ctx.wake_capable;
228 
229 	return irq_ctx.irq;
230 }
231 
i2c_acpi_get_info(struct acpi_device * adev,struct i2c_board_info * info,struct i2c_adapter * adapter,acpi_handle * adapter_handle)232 static int i2c_acpi_get_info(struct acpi_device *adev,
233 			     struct i2c_board_info *info,
234 			     struct i2c_adapter *adapter,
235 			     acpi_handle *adapter_handle)
236 {
237 	struct i2c_acpi_lookup lookup;
238 	int ret;
239 
240 	memset(&lookup, 0, sizeof(lookup));
241 	lookup.info = info;
242 	lookup.index = -1;
243 
244 	if (acpi_device_enumerated(adev))
245 		return -EINVAL;
246 
247 	ret = i2c_acpi_do_lookup(adev, &lookup);
248 	if (ret)
249 		return ret;
250 
251 	if (adapter) {
252 		/* The adapter must match the one in I2cSerialBus() connector */
253 		if (ACPI_HANDLE(&adapter->dev) != lookup.adapter_handle)
254 			return -ENODEV;
255 	} else {
256 		struct acpi_device *adapter_adev;
257 
258 		/* The adapter must be present */
259 		adapter_adev = acpi_fetch_acpi_dev(lookup.adapter_handle);
260 		if (!adapter_adev)
261 			return -ENODEV;
262 		if (acpi_bus_get_status(adapter_adev) ||
263 		    !adapter_adev->status.present)
264 			return -ENODEV;
265 	}
266 
267 	info->fwnode = acpi_fwnode_handle(adev);
268 	if (adapter_handle)
269 		*adapter_handle = lookup.adapter_handle;
270 
271 	acpi_set_modalias(adev, dev_name(&adev->dev), info->type,
272 			  sizeof(info->type));
273 
274 	return 0;
275 }
276 
i2c_acpi_register_device(struct i2c_adapter * adapter,struct acpi_device * adev,struct i2c_board_info * info)277 static void i2c_acpi_register_device(struct i2c_adapter *adapter,
278 				     struct acpi_device *adev,
279 				     struct i2c_board_info *info)
280 {
281 	/*
282 	 * Skip registration on boards where the ACPI tables are
283 	 * known to contain bogus I2C devices.
284 	 */
285 	if (acpi_quirk_skip_i2c_client_enumeration(adev))
286 		return;
287 
288 	adev->power.flags.ignore_parent = true;
289 	acpi_device_set_enumerated(adev);
290 
291 	if (IS_ERR(i2c_new_client_device(adapter, info)))
292 		adev->power.flags.ignore_parent = false;
293 }
294 
i2c_acpi_add_device(acpi_handle handle,u32 level,void * data,void ** return_value)295 static acpi_status i2c_acpi_add_device(acpi_handle handle, u32 level,
296 				       void *data, void **return_value)
297 {
298 	struct i2c_adapter *adapter = data;
299 	struct acpi_device *adev = acpi_fetch_acpi_dev(handle);
300 	struct i2c_board_info info;
301 
302 	if (!adev || i2c_acpi_get_info(adev, &info, adapter, NULL))
303 		return AE_OK;
304 
305 	i2c_acpi_register_device(adapter, adev, &info);
306 
307 	return AE_OK;
308 }
309 
310 #define I2C_ACPI_MAX_SCAN_DEPTH 32
311 
312 /**
313  * i2c_acpi_register_devices - enumerate I2C slave devices behind adapter
314  * @adap: pointer to adapter
315  *
316  * Enumerate all I2C slave devices behind this adapter by walking the ACPI
317  * namespace. When a device is found it will be added to the Linux device
318  * model and bound to the corresponding ACPI handle.
319  */
i2c_acpi_register_devices(struct i2c_adapter * adap)320 void i2c_acpi_register_devices(struct i2c_adapter *adap)
321 {
322 	struct acpi_device *adev;
323 	acpi_status status;
324 
325 	if (!has_acpi_companion(&adap->dev))
326 		return;
327 
328 	status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
329 				     I2C_ACPI_MAX_SCAN_DEPTH,
330 				     i2c_acpi_add_device, NULL,
331 				     adap, NULL);
332 	if (ACPI_FAILURE(status))
333 		dev_warn(&adap->dev, "failed to enumerate I2C slaves\n");
334 
335 	if (!adap->dev.parent)
336 		return;
337 
338 	adev = ACPI_COMPANION(adap->dev.parent);
339 	if (!adev)
340 		return;
341 
342 	acpi_dev_clear_dependencies(adev);
343 }
344 
345 static const struct acpi_device_id i2c_acpi_force_400khz_device_ids[] = {
346 	/*
347 	 * These Silead touchscreen controllers only work at 400KHz, for
348 	 * some reason they do not work at 100KHz. On some devices the ACPI
349 	 * tables list another device at their bus as only being capable
350 	 * of 100KHz, testing has shown that these other devices work fine
351 	 * at 400KHz (as can be expected of any recent i2c hw) so we force
352 	 * the speed of the bus to 400 KHz if a Silead device is present.
353 	 */
354 	{ "MSSL1680", 0 },
355 	{}
356 };
357 
i2c_acpi_lookup_speed(acpi_handle handle,u32 level,void * data,void ** return_value)358 static acpi_status i2c_acpi_lookup_speed(acpi_handle handle, u32 level,
359 					   void *data, void **return_value)
360 {
361 	struct i2c_acpi_lookup *lookup = data;
362 	struct acpi_device *adev = acpi_fetch_acpi_dev(handle);
363 
364 	if (!adev || i2c_acpi_do_lookup(adev, lookup))
365 		return AE_OK;
366 
367 	if (lookup->search_handle != lookup->adapter_handle)
368 		return AE_OK;
369 
370 	if (lookup->speed <= lookup->min_speed)
371 		lookup->min_speed = lookup->speed;
372 
373 	if (acpi_match_device_ids(adev, i2c_acpi_force_400khz_device_ids) == 0)
374 		lookup->force_speed = I2C_MAX_FAST_MODE_FREQ;
375 
376 	return AE_OK;
377 }
378 
379 /**
380  * i2c_acpi_find_bus_speed - find I2C bus speed from ACPI
381  * @dev: The device owning the bus
382  *
383  * Find the I2C bus speed by walking the ACPI namespace for all I2C slaves
384  * devices connected to this bus and use the speed of slowest device.
385  *
386  * Returns the speed in Hz or zero
387  */
i2c_acpi_find_bus_speed(struct device * dev)388 u32 i2c_acpi_find_bus_speed(struct device *dev)
389 {
390 	struct i2c_acpi_lookup lookup;
391 	struct i2c_board_info dummy;
392 	acpi_status status;
393 
394 	if (!has_acpi_companion(dev))
395 		return 0;
396 
397 	memset(&lookup, 0, sizeof(lookup));
398 	lookup.search_handle = ACPI_HANDLE(dev);
399 	lookup.min_speed = UINT_MAX;
400 	lookup.info = &dummy;
401 	lookup.index = -1;
402 
403 	status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
404 				     I2C_ACPI_MAX_SCAN_DEPTH,
405 				     i2c_acpi_lookup_speed, NULL,
406 				     &lookup, NULL);
407 
408 	if (ACPI_FAILURE(status)) {
409 		dev_warn(dev, "unable to find I2C bus speed from ACPI\n");
410 		return 0;
411 	}
412 
413 	if (lookup.force_speed) {
414 		if (lookup.force_speed != lookup.min_speed)
415 			dev_warn(dev, FW_BUG "DSDT uses known not-working I2C bus speed %d, forcing it to %d\n",
416 				 lookup.min_speed, lookup.force_speed);
417 		return lookup.force_speed;
418 	} else if (lookup.min_speed != UINT_MAX) {
419 		return lookup.min_speed;
420 	} else {
421 		return 0;
422 	}
423 }
424 EXPORT_SYMBOL_GPL(i2c_acpi_find_bus_speed);
425 
i2c_acpi_find_adapter_by_handle(acpi_handle handle)426 struct i2c_adapter *i2c_acpi_find_adapter_by_handle(acpi_handle handle)
427 {
428 	struct i2c_adapter *adapter;
429 	struct device *dev;
430 
431 	dev = bus_find_device(&i2c_bus_type, NULL, handle, device_match_acpi_handle);
432 	if (!dev)
433 		return NULL;
434 
435 	adapter = i2c_verify_adapter(dev);
436 	if (!adapter)
437 		put_device(dev);
438 
439 	return adapter;
440 }
441 EXPORT_SYMBOL_GPL(i2c_acpi_find_adapter_by_handle);
442 
i2c_acpi_find_client_by_adev(struct acpi_device * adev)443 static struct i2c_client *i2c_acpi_find_client_by_adev(struct acpi_device *adev)
444 {
445 	return i2c_find_device_by_fwnode(acpi_fwnode_handle(adev));
446 }
447 
i2c_acpi_find_adapter_by_adev(struct acpi_device * adev)448 static struct i2c_adapter *i2c_acpi_find_adapter_by_adev(struct acpi_device *adev)
449 {
450 	return i2c_find_adapter_by_fwnode(acpi_fwnode_handle(adev));
451 }
452 
i2c_acpi_notify(struct notifier_block * nb,unsigned long value,void * arg)453 static int i2c_acpi_notify(struct notifier_block *nb, unsigned long value,
454 			   void *arg)
455 {
456 	struct acpi_device *adev = arg;
457 	struct i2c_board_info info;
458 	acpi_handle adapter_handle;
459 	struct i2c_adapter *adapter;
460 	struct i2c_client *client;
461 
462 	switch (value) {
463 	case ACPI_RECONFIG_DEVICE_ADD:
464 		if (i2c_acpi_get_info(adev, &info, NULL, &adapter_handle))
465 			break;
466 
467 		adapter = i2c_acpi_find_adapter_by_handle(adapter_handle);
468 		if (!adapter)
469 			break;
470 
471 		i2c_acpi_register_device(adapter, adev, &info);
472 		put_device(&adapter->dev);
473 		break;
474 	case ACPI_RECONFIG_DEVICE_REMOVE:
475 		if (!acpi_device_enumerated(adev))
476 			break;
477 
478 		client = i2c_acpi_find_client_by_adev(adev);
479 		if (client) {
480 			i2c_unregister_device(client);
481 			put_device(&client->dev);
482 		}
483 
484 		adapter = i2c_acpi_find_adapter_by_adev(adev);
485 		if (adapter) {
486 			acpi_unbind_one(&adapter->dev);
487 			put_device(&adapter->dev);
488 		}
489 
490 		break;
491 	}
492 
493 	return NOTIFY_OK;
494 }
495 
496 struct notifier_block i2c_acpi_notifier = {
497 	.notifier_call = i2c_acpi_notify,
498 };
499 
500 /**
501  * i2c_acpi_new_device_by_fwnode - Create i2c-client for the Nth I2cSerialBus resource
502  * @fwnode:  fwnode with the ACPI resources to get the client from
503  * @index:   Index of ACPI resource to get
504  * @info:    describes the I2C device; note this is modified (addr gets set)
505  * Context: can sleep
506  *
507  * By default the i2c subsys creates an i2c-client for the first I2cSerialBus
508  * resource of an acpi_device, but some acpi_devices have multiple I2cSerialBus
509  * resources, in that case this function can be used to create an i2c-client
510  * for other I2cSerialBus resources in the Current Resource Settings table.
511  *
512  * Also see i2c_new_client_device, which this function calls to create the
513  * i2c-client.
514  *
515  * Returns a pointer to the new i2c-client, or error pointer in case of failure.
516  * Specifically, -EPROBE_DEFER is returned if the adapter is not found.
517  */
i2c_acpi_new_device_by_fwnode(struct fwnode_handle * fwnode,int index,struct i2c_board_info * info)518 struct i2c_client *i2c_acpi_new_device_by_fwnode(struct fwnode_handle *fwnode,
519 						 int index,
520 						 struct i2c_board_info *info)
521 {
522 	struct i2c_acpi_lookup lookup;
523 	struct i2c_adapter *adapter;
524 	struct acpi_device *adev;
525 	LIST_HEAD(resource_list);
526 	int ret;
527 
528 	adev = to_acpi_device_node(fwnode);
529 	if (!adev)
530 		return ERR_PTR(-ENODEV);
531 
532 	memset(&lookup, 0, sizeof(lookup));
533 	lookup.info = info;
534 	lookup.device_handle = acpi_device_handle(adev);
535 	lookup.index = index;
536 
537 	ret = acpi_dev_get_resources(adev, &resource_list,
538 				     i2c_acpi_fill_info, &lookup);
539 	if (ret < 0)
540 		return ERR_PTR(ret);
541 
542 	acpi_dev_free_resource_list(&resource_list);
543 
544 	if (!info->addr)
545 		return ERR_PTR(-EADDRNOTAVAIL);
546 
547 	adapter = i2c_acpi_find_adapter_by_handle(lookup.adapter_handle);
548 	if (!adapter)
549 		return ERR_PTR(-EPROBE_DEFER);
550 
551 	return i2c_new_client_device(adapter, info);
552 }
553 EXPORT_SYMBOL_GPL(i2c_acpi_new_device_by_fwnode);
554 
i2c_acpi_waive_d0_probe(struct device * dev)555 bool i2c_acpi_waive_d0_probe(struct device *dev)
556 {
557 	struct i2c_driver *driver = to_i2c_driver(dev->driver);
558 	struct acpi_device *adev = ACPI_COMPANION(dev);
559 
560 	return driver->flags & I2C_DRV_ACPI_WAIVE_D0_PROBE &&
561 		adev && adev->power.state_for_enumeration >= adev->power.state;
562 }
563 EXPORT_SYMBOL_GPL(i2c_acpi_waive_d0_probe);
564 
565 #ifdef CONFIG_ACPI_I2C_OPREGION
acpi_gsb_i2c_read_bytes(struct i2c_client * client,u8 cmd,u8 * data,u8 data_len)566 static int acpi_gsb_i2c_read_bytes(struct i2c_client *client,
567 		u8 cmd, u8 *data, u8 data_len)
568 {
569 
570 	struct i2c_msg msgs[2];
571 	int ret;
572 	u8 *buffer;
573 
574 	buffer = kzalloc(data_len, GFP_KERNEL);
575 	if (!buffer)
576 		return AE_NO_MEMORY;
577 
578 	msgs[0].addr = client->addr;
579 	msgs[0].flags = client->flags;
580 	msgs[0].len = 1;
581 	msgs[0].buf = &cmd;
582 
583 	msgs[1].addr = client->addr;
584 	msgs[1].flags = client->flags | I2C_M_RD;
585 	msgs[1].len = data_len;
586 	msgs[1].buf = buffer;
587 
588 	ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
589 	if (ret < 0) {
590 		/* Getting a NACK is unfortunately normal with some DSTDs */
591 		if (ret == -EREMOTEIO)
592 			dev_dbg(&client->adapter->dev, "i2c read %d bytes from client@%#x starting at reg %#x failed, error: %d\n",
593 				data_len, client->addr, cmd, ret);
594 		else
595 			dev_err(&client->adapter->dev, "i2c read %d bytes from client@%#x starting at reg %#x failed, error: %d\n",
596 				data_len, client->addr, cmd, ret);
597 	/* 2 transfers must have completed successfully */
598 	} else if (ret == 2) {
599 		memcpy(data, buffer, data_len);
600 		ret = 0;
601 	} else {
602 		ret = -EIO;
603 	}
604 
605 	kfree(buffer);
606 	return ret;
607 }
608 
acpi_gsb_i2c_write_bytes(struct i2c_client * client,u8 cmd,u8 * data,u8 data_len)609 static int acpi_gsb_i2c_write_bytes(struct i2c_client *client,
610 		u8 cmd, u8 *data, u8 data_len)
611 {
612 
613 	struct i2c_msg msgs[1];
614 	u8 *buffer;
615 	int ret = AE_OK;
616 
617 	buffer = kzalloc(data_len + 1, GFP_KERNEL);
618 	if (!buffer)
619 		return AE_NO_MEMORY;
620 
621 	buffer[0] = cmd;
622 	memcpy(buffer + 1, data, data_len);
623 
624 	msgs[0].addr = client->addr;
625 	msgs[0].flags = client->flags;
626 	msgs[0].len = data_len + 1;
627 	msgs[0].buf = buffer;
628 
629 	ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
630 
631 	kfree(buffer);
632 
633 	if (ret < 0) {
634 		dev_err(&client->adapter->dev, "i2c write failed: %d\n", ret);
635 		return ret;
636 	}
637 
638 	/* 1 transfer must have completed successfully */
639 	return (ret == 1) ? 0 : -EIO;
640 }
641 
642 static acpi_status
i2c_acpi_space_handler(u32 function,acpi_physical_address command,u32 bits,u64 * value64,void * handler_context,void * region_context)643 i2c_acpi_space_handler(u32 function, acpi_physical_address command,
644 			u32 bits, u64 *value64,
645 			void *handler_context, void *region_context)
646 {
647 	struct gsb_buffer *gsb = (struct gsb_buffer *)value64;
648 	struct i2c_acpi_handler_data *data = handler_context;
649 	struct acpi_connection_info *info = &data->info;
650 	struct acpi_resource_i2c_serialbus *sb;
651 	struct i2c_adapter *adapter = data->adapter;
652 	struct i2c_client *client;
653 	struct acpi_resource *ares;
654 	u32 accessor_type = function >> 16;
655 	u8 action = function & ACPI_IO_MASK;
656 	acpi_status ret;
657 	int status;
658 
659 	ret = acpi_buffer_to_resource(info->connection, info->length, &ares);
660 	if (ACPI_FAILURE(ret))
661 		return ret;
662 
663 	client = kzalloc(sizeof(*client), GFP_KERNEL);
664 	if (!client) {
665 		ret = AE_NO_MEMORY;
666 		goto err;
667 	}
668 
669 	if (!value64 || !i2c_acpi_get_i2c_resource(ares, &sb)) {
670 		ret = AE_BAD_PARAMETER;
671 		goto err;
672 	}
673 
674 	client->adapter = adapter;
675 	client->addr = sb->slave_address;
676 
677 	if (sb->access_mode == ACPI_I2C_10BIT_MODE)
678 		client->flags |= I2C_CLIENT_TEN;
679 
680 	switch (accessor_type) {
681 	case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV:
682 		if (action == ACPI_READ) {
683 			status = i2c_smbus_read_byte(client);
684 			if (status >= 0) {
685 				gsb->bdata = status;
686 				status = 0;
687 			}
688 		} else {
689 			status = i2c_smbus_write_byte(client, gsb->bdata);
690 		}
691 		break;
692 
693 	case ACPI_GSB_ACCESS_ATTRIB_BYTE:
694 		if (action == ACPI_READ) {
695 			status = i2c_smbus_read_byte_data(client, command);
696 			if (status >= 0) {
697 				gsb->bdata = status;
698 				status = 0;
699 			}
700 		} else {
701 			status = i2c_smbus_write_byte_data(client, command,
702 					gsb->bdata);
703 		}
704 		break;
705 
706 	case ACPI_GSB_ACCESS_ATTRIB_WORD:
707 		if (action == ACPI_READ) {
708 			status = i2c_smbus_read_word_data(client, command);
709 			if (status >= 0) {
710 				gsb->wdata = status;
711 				status = 0;
712 			}
713 		} else {
714 			status = i2c_smbus_write_word_data(client, command,
715 					gsb->wdata);
716 		}
717 		break;
718 
719 	case ACPI_GSB_ACCESS_ATTRIB_BLOCK:
720 		if (action == ACPI_READ) {
721 			status = i2c_smbus_read_block_data(client, command,
722 					gsb->data);
723 			if (status >= 0) {
724 				gsb->len = status;
725 				status = 0;
726 			}
727 		} else {
728 			status = i2c_smbus_write_block_data(client, command,
729 					gsb->len, gsb->data);
730 		}
731 		break;
732 
733 	case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE:
734 		if (action == ACPI_READ) {
735 			status = acpi_gsb_i2c_read_bytes(client, command,
736 					gsb->data, info->access_length);
737 		} else {
738 			status = acpi_gsb_i2c_write_bytes(client, command,
739 					gsb->data, info->access_length);
740 		}
741 		break;
742 
743 	default:
744 		dev_warn(&adapter->dev, "protocol 0x%02x not supported for client 0x%02x\n",
745 			 accessor_type, client->addr);
746 		ret = AE_BAD_PARAMETER;
747 		goto err;
748 	}
749 
750 	gsb->status = status;
751 
752  err:
753 	kfree(client);
754 	ACPI_FREE(ares);
755 	return ret;
756 }
757 
758 
i2c_acpi_install_space_handler(struct i2c_adapter * adapter)759 int i2c_acpi_install_space_handler(struct i2c_adapter *adapter)
760 {
761 	acpi_handle handle;
762 	struct i2c_acpi_handler_data *data;
763 	acpi_status status;
764 
765 	if (!adapter->dev.parent)
766 		return -ENODEV;
767 
768 	handle = ACPI_HANDLE(adapter->dev.parent);
769 
770 	if (!handle)
771 		return -ENODEV;
772 
773 	data = kzalloc(sizeof(struct i2c_acpi_handler_data),
774 			    GFP_KERNEL);
775 	if (!data)
776 		return -ENOMEM;
777 
778 	data->adapter = adapter;
779 	status = acpi_bus_attach_private_data(handle, (void *)data);
780 	if (ACPI_FAILURE(status)) {
781 		kfree(data);
782 		return -ENOMEM;
783 	}
784 
785 	status = acpi_install_address_space_handler(handle,
786 				ACPI_ADR_SPACE_GSBUS,
787 				&i2c_acpi_space_handler,
788 				NULL,
789 				data);
790 	if (ACPI_FAILURE(status)) {
791 		dev_err(&adapter->dev, "Error installing i2c space handler\n");
792 		acpi_bus_detach_private_data(handle);
793 		kfree(data);
794 		return -ENOMEM;
795 	}
796 
797 	return 0;
798 }
799 
i2c_acpi_remove_space_handler(struct i2c_adapter * adapter)800 void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter)
801 {
802 	acpi_handle handle;
803 	struct i2c_acpi_handler_data *data;
804 	acpi_status status;
805 
806 	if (!adapter->dev.parent)
807 		return;
808 
809 	handle = ACPI_HANDLE(adapter->dev.parent);
810 
811 	if (!handle)
812 		return;
813 
814 	acpi_remove_address_space_handler(handle,
815 				ACPI_ADR_SPACE_GSBUS,
816 				&i2c_acpi_space_handler);
817 
818 	status = acpi_bus_get_private_data(handle, (void **)&data);
819 	if (ACPI_SUCCESS(status))
820 		kfree(data);
821 
822 	acpi_bus_detach_private_data(handle);
823 }
824 #endif /* CONFIG_ACPI_I2C_OPREGION */
825