i2c-core-acpi.c

  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
 18struct i2c_acpi_handler_data {
 19	struct acpi_connection_info info;
 20	struct i2c_adapter *adapter;
 21};
 22
 23struct 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
 33struct 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 */
 55bool 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}
 70EXPORT_SYMBOL_GPL(i2c_acpi_get_i2c_resource);
 71
 72static 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 */
 90int 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}
102EXPORT_SYMBOL_GPL(i2c_acpi_client_count);
103
104static 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
131static 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
140struct i2c_acpi_irq_context {
141	int irq;
142	bool wake_capable;
143};
144
145static 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
176static 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 */
202int 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
232static 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 (!device_match_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
277static 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
295static 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 */
320void 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
345static 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
358static const struct acpi_device_id i2c_acpi_force_100khz_device_ids[] = {
359	/*
360	 * When a 400KHz freq is used on this model of ELAN touchpad in Linux,
361	 * excessive smoothing (similar to when the touchpad's firmware detects
362	 * a noisy signal) is sometimes applied. As some devices' (e.g, Lenovo
363	 * V15 G4) ACPI tables specify a 400KHz frequency for this device and
364	 * some I2C busses (e.g, Designware I2C) default to a 400KHz freq,
365	 * force the speed to 100KHz as a workaround.
366	 *
367	 * For future investigation: This problem may be related to the default
368	 * HCNT/LCNT values given by some busses' drivers, because they are not
369	 * specified in the aforementioned devices' ACPI tables, and because
370	 * the device works without issues on Windows at what is expected to be
371	 * a 400KHz frequency. The root cause of the issue is not known.
372	 */
373	{ "DLL0945", 0 },
374	{ "ELAN06FA", 0 },
375	{}
376};
377
378static acpi_status i2c_acpi_lookup_speed(acpi_handle handle, u32 level,
379					   void *data, void **return_value)
380{
381	struct i2c_acpi_lookup *lookup = data;
382	struct acpi_device *adev = acpi_fetch_acpi_dev(handle);
383
384	if (!adev || i2c_acpi_do_lookup(adev, lookup))
385		return AE_OK;
386
387	if (lookup->search_handle != lookup->adapter_handle)
388		return AE_OK;
389
390	if (lookup->speed <= lookup->min_speed)
391		lookup->min_speed = lookup->speed;
392
393	if (acpi_match_device_ids(adev, i2c_acpi_force_400khz_device_ids) == 0)
394		lookup->force_speed = I2C_MAX_FAST_MODE_FREQ;
395
396	if (acpi_match_device_ids(adev, i2c_acpi_force_100khz_device_ids) == 0)
397		lookup->force_speed = I2C_MAX_STANDARD_MODE_FREQ;
398
399	return AE_OK;
400}
401
402/**
403 * i2c_acpi_find_bus_speed - find I2C bus speed from ACPI
404 * @dev: The device owning the bus
405 *
406 * Find the I2C bus speed by walking the ACPI namespace for all I2C slaves
407 * devices connected to this bus and use the speed of slowest device.
408 *
409 * Returns the speed in Hz or zero
410 */
411u32 i2c_acpi_find_bus_speed(struct device *dev)
412{
413	struct i2c_acpi_lookup lookup;
414	struct i2c_board_info dummy;
415	acpi_status status;
416
417	if (!has_acpi_companion(dev))
418		return 0;
419
420	memset(&lookup, 0, sizeof(lookup));
421	lookup.search_handle = ACPI_HANDLE(dev);
422	lookup.min_speed = UINT_MAX;
423	lookup.info = &dummy;
424	lookup.index = -1;
425
426	status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
427				     I2C_ACPI_MAX_SCAN_DEPTH,
428				     i2c_acpi_lookup_speed, NULL,
429				     &lookup, NULL);
430
431	if (ACPI_FAILURE(status)) {
432		dev_warn(dev, "unable to find I2C bus speed from ACPI\n");
433		return 0;
434	}
435
436	if (lookup.force_speed) {
437		if (lookup.force_speed != lookup.min_speed)
438			dev_warn(dev, FW_BUG "DSDT uses known not-working I2C bus speed %d, forcing it to %d\n",
439				 lookup.min_speed, lookup.force_speed);
440		return lookup.force_speed;
441	} else if (lookup.min_speed != UINT_MAX) {
442		return lookup.min_speed;
443	} else {
444		return 0;
445	}
446}
447EXPORT_SYMBOL_GPL(i2c_acpi_find_bus_speed);
448
449struct i2c_adapter *i2c_acpi_find_adapter_by_handle(acpi_handle handle)
450{
451	struct i2c_adapter *adapter;
452	struct device *dev;
453
454	dev = bus_find_device(&i2c_bus_type, NULL, handle, device_match_acpi_handle);
455	if (!dev)
456		return NULL;
457
458	adapter = i2c_verify_adapter(dev);
459	if (!adapter)
460		put_device(dev);
461
462	return adapter;
463}
464EXPORT_SYMBOL_GPL(i2c_acpi_find_adapter_by_handle);
465
466static struct i2c_client *i2c_acpi_find_client_by_adev(struct acpi_device *adev)
467{
468	return i2c_find_device_by_fwnode(acpi_fwnode_handle(adev));
469}
470
471static struct i2c_adapter *i2c_acpi_find_adapter_by_adev(struct acpi_device *adev)
472{
473	return i2c_find_adapter_by_fwnode(acpi_fwnode_handle(adev));
474}
475
476static int i2c_acpi_notify(struct notifier_block *nb, unsigned long value,
477			   void *arg)
478{
479	struct acpi_device *adev = arg;
480	struct i2c_board_info info;
481	acpi_handle adapter_handle;
482	struct i2c_adapter *adapter;
483	struct i2c_client *client;
484
485	switch (value) {
486	case ACPI_RECONFIG_DEVICE_ADD:
487		if (i2c_acpi_get_info(adev, &info, NULL, &adapter_handle))
488			break;
489
490		adapter = i2c_acpi_find_adapter_by_handle(adapter_handle);
491		if (!adapter)
492			break;
493
494		i2c_acpi_register_device(adapter, adev, &info);
495		put_device(&adapter->dev);
496		break;
497	case ACPI_RECONFIG_DEVICE_REMOVE:
498		if (!acpi_device_enumerated(adev))
499			break;
500
501		client = i2c_acpi_find_client_by_adev(adev);
502		if (client) {
503			i2c_unregister_device(client);
504			put_device(&client->dev);
505		}
506
507		adapter = i2c_acpi_find_adapter_by_adev(adev);
508		if (adapter) {
509			acpi_unbind_one(&adapter->dev);
510			put_device(&adapter->dev);
511		}
512
513		break;
514	}
515
516	return NOTIFY_OK;
517}
518
519struct notifier_block i2c_acpi_notifier = {
520	.notifier_call = i2c_acpi_notify,
521};
522
523/**
524 * i2c_acpi_new_device_by_fwnode - Create i2c-client for the Nth I2cSerialBus resource
525 * @fwnode:  fwnode with the ACPI resources to get the client from
526 * @index:   Index of ACPI resource to get
527 * @info:    describes the I2C device; note this is modified (addr gets set)
528 * Context: can sleep
529 *
530 * By default the i2c subsys creates an i2c-client for the first I2cSerialBus
531 * resource of an acpi_device, but some acpi_devices have multiple I2cSerialBus
532 * resources, in that case this function can be used to create an i2c-client
533 * for other I2cSerialBus resources in the Current Resource Settings table.
534 *
535 * Also see i2c_new_client_device, which this function calls to create the
536 * i2c-client.
537 *
538 * Returns a pointer to the new i2c-client, or error pointer in case of failure.
539 * Specifically, -EPROBE_DEFER is returned if the adapter is not found.
540 */
541struct i2c_client *i2c_acpi_new_device_by_fwnode(struct fwnode_handle *fwnode,
542						 int index,
543						 struct i2c_board_info *info)
544{
545	struct i2c_acpi_lookup lookup;
546	struct i2c_adapter *adapter;
547	struct acpi_device *adev;
548	LIST_HEAD(resource_list);
549	int ret;
550
551	adev = to_acpi_device_node(fwnode);
552	if (!adev)
553		return ERR_PTR(-ENODEV);
554
555	memset(&lookup, 0, sizeof(lookup));
556	lookup.info = info;
557	lookup.device_handle = acpi_device_handle(adev);
558	lookup.index = index;
559
560	ret = acpi_dev_get_resources(adev, &resource_list,
561				     i2c_acpi_fill_info, &lookup);
562	if (ret < 0)
563		return ERR_PTR(ret);
564
565	acpi_dev_free_resource_list(&resource_list);
566
567	if (!info->addr)
568		return ERR_PTR(-EADDRNOTAVAIL);
569
570	adapter = i2c_acpi_find_adapter_by_handle(lookup.adapter_handle);
571	if (!adapter)
572		return ERR_PTR(-EPROBE_DEFER);
573
574	return i2c_new_client_device(adapter, info);
575}
576EXPORT_SYMBOL_GPL(i2c_acpi_new_device_by_fwnode);
577
578bool i2c_acpi_waive_d0_probe(struct device *dev)
579{
580	struct i2c_driver *driver = to_i2c_driver(dev->driver);
581	struct acpi_device *adev = ACPI_COMPANION(dev);
582
583	return driver->flags & I2C_DRV_ACPI_WAIVE_D0_PROBE &&
584		adev && adev->power.state_for_enumeration >= adev->power.state;
585}
586EXPORT_SYMBOL_GPL(i2c_acpi_waive_d0_probe);
587
588#ifdef CONFIG_ACPI_I2C_OPREGION
589static int acpi_gsb_i2c_read_bytes(struct i2c_client *client,
590		u8 cmd, u8 *data, u8 data_len)
591{
592
593	struct i2c_msg msgs[2];
594	int ret;
595	u8 *buffer;
596
597	buffer = kzalloc(data_len, GFP_KERNEL);
598	if (!buffer)
599		return AE_NO_MEMORY;
600
601	msgs[0].addr = client->addr;
602	msgs[0].flags = client->flags;
603	msgs[0].len = 1;
604	msgs[0].buf = &cmd;
605
606	msgs[1].addr = client->addr;
607	msgs[1].flags = client->flags | I2C_M_RD;
608	msgs[1].len = data_len;
609	msgs[1].buf = buffer;
610
611	ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
612	if (ret < 0) {
613		/* Getting a NACK is unfortunately normal with some DSTDs */
614		if (ret == -EREMOTEIO)
615			dev_dbg(&client->adapter->dev, "i2c read %d bytes from client@%#x starting at reg %#x failed, error: %d\n",
616				data_len, client->addr, cmd, ret);
617		else
618			dev_err(&client->adapter->dev, "i2c read %d bytes from client@%#x starting at reg %#x failed, error: %d\n",
619				data_len, client->addr, cmd, ret);
620	/* 2 transfers must have completed successfully */
621	} else if (ret == 2) {
622		memcpy(data, buffer, data_len);
623		ret = 0;
624	} else {
625		ret = -EIO;
626	}
627
628	kfree(buffer);
629	return ret;
630}
631
632static int acpi_gsb_i2c_write_bytes(struct i2c_client *client,
633		u8 cmd, u8 *data, u8 data_len)
634{
635
636	struct i2c_msg msgs[1];
637	u8 *buffer;
638	int ret = AE_OK;
639
640	buffer = kzalloc(data_len + 1, GFP_KERNEL);
641	if (!buffer)
642		return AE_NO_MEMORY;
643
644	buffer[0] = cmd;
645	memcpy(buffer + 1, data, data_len);
646
647	msgs[0].addr = client->addr;
648	msgs[0].flags = client->flags;
649	msgs[0].len = data_len + 1;
650	msgs[0].buf = buffer;
651
652	ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
653
654	kfree(buffer);
655
656	if (ret < 0) {
657		dev_err(&client->adapter->dev, "i2c write failed: %d\n", ret);
658		return ret;
659	}
660
661	/* 1 transfer must have completed successfully */
662	return (ret == 1) ? 0 : -EIO;
663}
664
665static acpi_status
666i2c_acpi_space_handler(u32 function, acpi_physical_address command,
667			u32 bits, u64 *value64,
668			void *handler_context, void *region_context)
669{
670	struct gsb_buffer *gsb = (struct gsb_buffer *)value64;
671	struct i2c_acpi_handler_data *data = handler_context;
672	struct acpi_connection_info *info = &data->info;
673	struct acpi_resource_i2c_serialbus *sb;
674	struct i2c_adapter *adapter = data->adapter;
675	struct i2c_client *client;
676	struct acpi_resource *ares;
677	u32 accessor_type = function >> 16;
678	u8 action = function & ACPI_IO_MASK;
679	acpi_status ret;
680	int status;
681
682	ret = acpi_buffer_to_resource(info->connection, info->length, &ares);
683	if (ACPI_FAILURE(ret))
684		return ret;
685
686	client = kzalloc(sizeof(*client), GFP_KERNEL);
687	if (!client) {
688		ret = AE_NO_MEMORY;
689		goto err;
690	}
691
692	if (!value64 || !i2c_acpi_get_i2c_resource(ares, &sb)) {
693		ret = AE_BAD_PARAMETER;
694		goto err;
695	}
696
697	client->adapter = adapter;
698	client->addr = sb->slave_address;
699
700	if (sb->access_mode == ACPI_I2C_10BIT_MODE)
701		client->flags |= I2C_CLIENT_TEN;
702
703	switch (accessor_type) {
704	case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV:
705		if (action == ACPI_READ) {
706			status = i2c_smbus_read_byte(client);
707			if (status >= 0) {
708				gsb->bdata = status;
709				status = 0;
710			}
711		} else {
712			status = i2c_smbus_write_byte(client, gsb->bdata);
713		}
714		break;
715
716	case ACPI_GSB_ACCESS_ATTRIB_BYTE:
717		if (action == ACPI_READ) {
718			status = i2c_smbus_read_byte_data(client, command);
719			if (status >= 0) {
720				gsb->bdata = status;
721				status = 0;
722			}
723		} else {
724			status = i2c_smbus_write_byte_data(client, command,
725					gsb->bdata);
726		}
727		break;
728
729	case ACPI_GSB_ACCESS_ATTRIB_WORD:
730		if (action == ACPI_READ) {
731			status = i2c_smbus_read_word_data(client, command);
732			if (status >= 0) {
733				gsb->wdata = status;
734				status = 0;
735			}
736		} else {
737			status = i2c_smbus_write_word_data(client, command,
738					gsb->wdata);
739		}
740		break;
741
742	case ACPI_GSB_ACCESS_ATTRIB_BLOCK:
743		if (action == ACPI_READ) {
744			status = i2c_smbus_read_block_data(client, command,
745					gsb->data);
746			if (status >= 0) {
747				gsb->len = status;
748				status = 0;
749			}
750		} else {
751			status = i2c_smbus_write_block_data(client, command,
752					gsb->len, gsb->data);
753		}
754		break;
755
756	case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE:
757		if (action == ACPI_READ) {
758			status = acpi_gsb_i2c_read_bytes(client, command,
759					gsb->data, info->access_length);
760		} else {
761			status = acpi_gsb_i2c_write_bytes(client, command,
762					gsb->data, info->access_length);
763		}
764		break;
765
766	default:
767		dev_warn(&adapter->dev, "protocol 0x%02x not supported for client 0x%02x\n",
768			 accessor_type, client->addr);
769		ret = AE_BAD_PARAMETER;
770		goto err;
771	}
772
773	gsb->status = status;
774
775 err:
776	kfree(client);
777	ACPI_FREE(ares);
778	return ret;
779}
780
781
782int i2c_acpi_install_space_handler(struct i2c_adapter *adapter)
783{
784	acpi_handle handle;
785	struct i2c_acpi_handler_data *data;
786	acpi_status status;
787
788	if (!adapter->dev.parent)
789		return -ENODEV;
790
791	handle = ACPI_HANDLE(adapter->dev.parent);
792
793	if (!handle)
794		return -ENODEV;
795
796	data = kzalloc(sizeof(struct i2c_acpi_handler_data),
797			    GFP_KERNEL);
798	if (!data)
799		return -ENOMEM;
800
801	data->adapter = adapter;
802	status = acpi_bus_attach_private_data(handle, (void *)data);
803	if (ACPI_FAILURE(status)) {
804		kfree(data);
805		return -ENOMEM;
806	}
807
808	status = acpi_install_address_space_handler(handle,
809				ACPI_ADR_SPACE_GSBUS,
810				&i2c_acpi_space_handler,
811				NULL,
812				data);
813	if (ACPI_FAILURE(status)) {
814		dev_err(&adapter->dev, "Error installing i2c space handler\n");
815		acpi_bus_detach_private_data(handle);
816		kfree(data);
817		return -ENOMEM;
818	}
819
820	return 0;
821}
822
823void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter)
824{
825	acpi_handle handle;
826	struct i2c_acpi_handler_data *data;
827	acpi_status status;
828
829	if (!adapter->dev.parent)
830		return;
831
832	handle = ACPI_HANDLE(adapter->dev.parent);
833
834	if (!handle)
835		return;
836
837	acpi_remove_address_space_handler(handle,
838				ACPI_ADR_SPACE_GSBUS,
839				&i2c_acpi_space_handler);
840
841	status = acpi_bus_get_private_data(handle, (void **)&data);
842	if (ACPI_SUCCESS(status))
843		kfree(data);
844
845	acpi_bus_detach_private_data(handle);
846}
847#endif /* CONFIG_ACPI_I2C_OPREGION */