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