i2c-core-base.c 75.9 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
6
7
8
9
10
11
12
/* i2c-core.c - a device driver for the iic-bus interface		     */
/* ------------------------------------------------------------------------- */
/*   Copyright (C) 1995-99 Simon G. Vogl

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
Wolfram Sang's avatar
Wolfram Sang committed
13
    GNU General Public License for more details.			     */
Linus Torvalds's avatar
Linus Torvalds committed
14
15
/* ------------------------------------------------------------------------- */

16
/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>.
17
   Mux support by Rodolfo Giometti <giometti@enneenne.com> and
18
   Michael Lawnick <michael.lawnick.ext@nsn.com>
19
20
   I2C ACPI code Copyright (C) 2014 Intel Corp
   Author: Lan Tianyu <tianyu.lan@intel.com>
21
 */
Linus Torvalds's avatar
Linus Torvalds committed
22

Wolfram Sang's avatar
Wolfram Sang committed
23
24
#define pr_fmt(fmt) "i2c-core: " fmt

25
#include <dt-bindings/i2c/i2c.h>
26
#include <linux/uaccess.h>
Wolfram Sang's avatar
Wolfram Sang committed
27
28
29
#include <linux/acpi.h>
#include <linux/clk/clk-conf.h>
#include <linux/completion.h>
30
#include <linux/delay.h>
Wolfram Sang's avatar
Wolfram Sang committed
31
#include <linux/err.h>
Linus Torvalds's avatar
Linus Torvalds committed
32
#include <linux/errno.h>
33
#include <linux/gpio.h>
Wolfram Sang's avatar
Wolfram Sang committed
34
#include <linux/hardirq.h>
Linus Torvalds's avatar
Linus Torvalds committed
35
36
#include <linux/i2c.h>
#include <linux/idr.h>
Wolfram Sang's avatar
Wolfram Sang committed
37
38
39
40
41
#include <linux/init.h>
#include <linux/irqflags.h>
#include <linux/jump_label.h>
#include <linux/kernel.h>
#include <linux/module.h>
42
#include <linux/mutex.h>
43
#include <linux/of_device.h>
Wolfram Sang's avatar
Wolfram Sang committed
44
#include <linux/of.h>
45
#include <linux/of_irq.h>
46
#include <linux/pm_domain.h>
Wolfram Sang's avatar
Wolfram Sang committed
47
#include <linux/pm_runtime.h>
48
#include <linux/pm_wakeirq.h>
49
#include <linux/property.h>
Wolfram Sang's avatar
Wolfram Sang committed
50
51
#include <linux/rwsem.h>
#include <linux/slab.h>
Linus Torvalds's avatar
Linus Torvalds committed
52

53
54
#include "i2c-core.h"

55
56
#define CREATE_TRACE_POINTS
#include <trace/events/i2c.h>
Linus Torvalds's avatar
Linus Torvalds committed
57

58
59
60
#define I2C_ADDR_OFFSET_TEN_BIT	0xa000
#define I2C_ADDR_OFFSET_SLAVE	0x1000

61
62
63
#define I2C_ADDR_7BITS_MAX	0x77
#define I2C_ADDR_7BITS_COUNT	(I2C_ADDR_7BITS_MAX + 1)

64
/* core_lock protects i2c_adapter_idr, and guarantees
65
   that device detection, deletion of detected devices, and attach_adapter
66
   calls are serialized */
Jean Delvare's avatar
Jean Delvare committed
67
static DEFINE_MUTEX(core_lock);
Linus Torvalds's avatar
Linus Torvalds committed
68
69
static DEFINE_IDR(i2c_adapter_idr);

70
static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
71

72
static struct static_key i2c_trace_msg = STATIC_KEY_INIT_FALSE;
73
static bool is_registered;
74

75
int i2c_transfer_trace_reg(void)
76
77
{
	static_key_slow_inc(&i2c_trace_msg);
78
	return 0;
79
80
81
82
83
84
85
}

void i2c_transfer_trace_unreg(void)
{
	static_key_slow_dec(&i2c_trace_msg);
}

86
#if defined(CONFIG_ACPI)
87
struct i2c_acpi_handler_data {
88
89
90
91
92
93
94
95
96
97
98
99
100
101
	struct acpi_connection_info info;
	struct i2c_adapter *adapter;
};

struct gsb_buffer {
	u8	status;
	u8	len;
	union {
		u16	wdata;
		u8	bdata;
		u8	data[0];
	};
} __packed;

102
struct i2c_acpi_lookup {
103
104
105
	struct i2c_board_info *info;
	acpi_handle adapter_handle;
	acpi_handle device_handle;
106
	acpi_handle search_handle;
107
108
	int n;
	int index;
109
110
	u32 speed;
	u32 min_speed;
111
};
112

113
static int i2c_acpi_fill_info(struct acpi_resource *ares, void *data)
114
{
115
	struct i2c_acpi_lookup *lookup = data;
116
117
118
	struct i2c_board_info *info = lookup->info;
	struct acpi_resource_i2c_serialbus *sb;
	acpi_status status;
119

120
121
122
123
124
125
126
	if (info->addr || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS)
		return 1;

	sb = &ares->data.i2c_serial_bus;
	if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C)
		return 1;

127
128
129
	if (lookup->index != -1 && lookup->n++ != lookup->index)
		return 1;

130
131
	status = acpi_get_handle(lookup->device_handle,
				 sb->resource_source.string_ptr,
132
133
134
135
136
				 &lookup->adapter_handle);
	if (!ACPI_SUCCESS(status))
		return 1;

	info->addr = sb->slave_address;
137
	lookup->speed = sb->connection_speed;
138
139
	if (sb->access_mode == ACPI_I2C_10BIT_MODE)
		info->flags |= I2C_CLIENT_TEN;
140
141
142
143

	return 1;
}

144
145
static int i2c_acpi_do_lookup(struct acpi_device *adev,
			      struct i2c_acpi_lookup *lookup)
146
{
147
	struct i2c_board_info *info = lookup->info;
148
149
150
	struct list_head resource_list;
	int ret;

151
152
153
	if (acpi_bus_get_status(adev) || !adev->status.present ||
	    acpi_device_enumerated(adev))
		return -EINVAL;
154

155
	memset(info, 0, sizeof(*info));
156
	lookup->device_handle = acpi_device_handle(adev);
157

158
	/* Look up for I2cSerialBus resource */
159
160
	INIT_LIST_HEAD(&resource_list);
	ret = acpi_dev_get_resources(adev, &resource_list,
161
				     i2c_acpi_fill_info, lookup);
162
163
	acpi_dev_free_resource_list(&resource_list);

164
165
166
	if (ret < 0 || !info->addr)
		return -EINVAL;

167
168
169
170
171
	return 0;
}

static int i2c_acpi_get_info(struct acpi_device *adev,
			     struct i2c_board_info *info,
172
			     struct i2c_adapter *adapter,
173
174
175
176
177
178
179
180
181
			     acpi_handle *adapter_handle)
{
	struct list_head resource_list;
	struct resource_entry *entry;
	struct i2c_acpi_lookup lookup;
	int ret;

	memset(&lookup, 0, sizeof(lookup));
	lookup.info = info;
182
	lookup.index = -1;
183
184
185
186
187

	ret = i2c_acpi_do_lookup(adev, &lookup);
	if (ret)
		return ret;

188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
	if (adapter) {
		/* The adapter must match the one in I2cSerialBus() connector */
		if (ACPI_HANDLE(&adapter->dev) != lookup.adapter_handle)
			return -ENODEV;
	} else {
		struct acpi_device *adapter_adev;

		/* The adapter must be present */
		if (acpi_bus_get_device(lookup.adapter_handle, &adapter_adev))
			return -ENODEV;
		if (acpi_bus_get_status(adapter_adev) ||
		    !adapter_adev->status.present)
			return -ENODEV;
	}

203
	info->fwnode = acpi_fwnode_handle(adev);
204
205
	if (adapter_handle)
		*adapter_handle = lookup.adapter_handle;
206

207
	/* Then fill IRQ number if any */
208
	INIT_LIST_HEAD(&resource_list);
209
210
	ret = acpi_dev_get_resources(adev, &resource_list, NULL, NULL);
	if (ret < 0)
211
		return -EINVAL;
212
213
214

	resource_list_for_each_entry(entry, &resource_list) {
		if (resource_type(entry->res) == IORESOURCE_IRQ) {
215
			info->irq = entry->res->start;
216
217
218
219
220
221
			break;
		}
	}

	acpi_dev_free_resource_list(&resource_list);

222
223
	acpi_set_modalias(adev, dev_name(&adev->dev), info->type,
			  sizeof(info->type));
224
225
226
227

	return 0;
}

228
static void i2c_acpi_register_device(struct i2c_adapter *adapter,
229
230
231
				     struct acpi_device *adev,
				     struct i2c_board_info *info)
{
232
	adev->power.flags.ignore_parent = true;
233
234
235
	acpi_device_set_enumerated(adev);

	if (!i2c_new_device(adapter, info)) {
236
237
238
239
240
		adev->power.flags.ignore_parent = false;
		dev_err(&adapter->dev,
			"failed to add I2C device %s from ACPI\n",
			dev_name(&adev->dev));
	}
241
242
}

243
static acpi_status i2c_acpi_add_device(acpi_handle handle, u32 level,
244
245
246
247
248
249
250
251
252
				       void *data, void **return_value)
{
	struct i2c_adapter *adapter = data;
	struct acpi_device *adev;
	struct i2c_board_info info;

	if (acpi_bus_get_device(handle, &adev))
		return AE_OK;

253
	if (i2c_acpi_get_info(adev, &info, adapter, NULL))
254
255
		return AE_OK;

256
	i2c_acpi_register_device(adapter, adev, &info);
257
258
259
260

	return AE_OK;
}

261
#define I2C_ACPI_MAX_SCAN_DEPTH 32
262

263
/**
264
 * i2c_acpi_register_devices - enumerate I2C slave devices behind adapter
265
266
267
268
269
270
 * @adap: pointer to adapter
 *
 * Enumerate all I2C slave devices behind this adapter by walking the ACPI
 * namespace. When a device is found it will be added to the Linux device
 * model and bound to the corresponding ACPI handle.
 */
271
static void i2c_acpi_register_devices(struct i2c_adapter *adap)
272
273
274
{
	acpi_status status;

275
	if (!has_acpi_companion(&adap->dev))
276
277
		return;

278
	status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
279
280
				     I2C_ACPI_MAX_SCAN_DEPTH,
				     i2c_acpi_add_device, NULL,
281
282
283
284
285
				     adap, NULL);
	if (ACPI_FAILURE(status))
		dev_warn(&adap->dev, "failed to enumerate I2C slaves\n");
}

286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
static acpi_status i2c_acpi_lookup_speed(acpi_handle handle, u32 level,
					   void *data, void **return_value)
{
	struct i2c_acpi_lookup *lookup = data;
	struct acpi_device *adev;

	if (acpi_bus_get_device(handle, &adev))
		return AE_OK;

	if (i2c_acpi_do_lookup(adev, lookup))
		return AE_OK;

	if (lookup->search_handle != lookup->adapter_handle)
		return AE_OK;

	if (lookup->speed <= lookup->min_speed)
		lookup->min_speed = lookup->speed;

	return AE_OK;
}

/**
 * i2c_acpi_find_bus_speed - find I2C bus speed from ACPI
 * @dev: The device owning the bus
 *
 * Find the I2C bus speed by walking the ACPI namespace for all I2C slaves
 * devices connected to this bus and use the speed of slowest device.
 *
 * Returns the speed in Hz or zero
 */
u32 i2c_acpi_find_bus_speed(struct device *dev)
{
	struct i2c_acpi_lookup lookup;
	struct i2c_board_info dummy;
	acpi_status status;

	if (!has_acpi_companion(dev))
		return 0;

	memset(&lookup, 0, sizeof(lookup));
	lookup.search_handle = ACPI_HANDLE(dev);
	lookup.min_speed = UINT_MAX;
	lookup.info = &dummy;
329
	lookup.index = -1;
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344

	status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
				     I2C_ACPI_MAX_SCAN_DEPTH,
				     i2c_acpi_lookup_speed, NULL,
				     &lookup, NULL);

	if (ACPI_FAILURE(status)) {
		dev_warn(dev, "unable to find I2C bus speed from ACPI\n");
		return 0;
	}

	return lookup.min_speed != UINT_MAX ? lookup.min_speed : 0;
}
EXPORT_SYMBOL_GPL(i2c_acpi_find_bus_speed);

345
static int i2c_acpi_match_adapter(struct device *dev, void *data)
346
347
348
349
350
351
352
353
354
{
	struct i2c_adapter *adapter = i2c_verify_adapter(dev);

	if (!adapter)
		return 0;

	return ACPI_HANDLE(dev) == (acpi_handle)data;
}

355
static int i2c_acpi_match_device(struct device *dev, void *data)
356
357
358
359
{
	return ACPI_COMPANION(dev) == data;
}

360
static struct i2c_adapter *i2c_acpi_find_adapter_by_handle(acpi_handle handle)
361
362
363
364
{
	struct device *dev;

	dev = bus_find_device(&i2c_bus_type, NULL, handle,
365
			      i2c_acpi_match_adapter);
366
367
368
	return dev ? i2c_verify_adapter(dev) : NULL;
}

369
static struct i2c_client *i2c_acpi_find_client_by_adev(struct acpi_device *adev)
370
371
372
{
	struct device *dev;

373
	dev = bus_find_device(&i2c_bus_type, NULL, adev, i2c_acpi_match_device);
374
375
376
	return dev ? i2c_verify_client(dev) : NULL;
}

377
static int i2c_acpi_notify(struct notifier_block *nb, unsigned long value,
378
379
380
381
382
383
384
385
386
387
			   void *arg)
{
	struct acpi_device *adev = arg;
	struct i2c_board_info info;
	acpi_handle adapter_handle;
	struct i2c_adapter *adapter;
	struct i2c_client *client;

	switch (value) {
	case ACPI_RECONFIG_DEVICE_ADD:
388
		if (i2c_acpi_get_info(adev, &info, NULL, &adapter_handle))
389
390
			break;

391
		adapter = i2c_acpi_find_adapter_by_handle(adapter_handle);
392
393
394
		if (!adapter)
			break;

395
		i2c_acpi_register_device(adapter, adev, &info);
396
397
398
399
400
		break;
	case ACPI_RECONFIG_DEVICE_REMOVE:
		if (!acpi_device_enumerated(adev))
			break;

401
		client = i2c_acpi_find_client_by_adev(adev);
402
403
404
405
406
407
408
409
410
411
412
413
		if (!client)
			break;

		i2c_unregister_device(client);
		put_device(&client->dev);
		break;
	}

	return NOTIFY_OK;
}

static struct notifier_block i2c_acpi_notifier = {
414
	.notifier_call = i2c_acpi_notify,
415
};
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464

/**
 * i2c_acpi_new_device - Create i2c-client for the Nth I2cSerialBus resource
 * @dev:     Device owning the ACPI resources to get the client from
 * @index:   Index of ACPI resource to get
 * @info:    describes the I2C device; note this is modified (addr gets set)
 * Context: can sleep
 *
 * By default the i2c subsys creates an i2c-client for the first I2cSerialBus
 * resource of an acpi_device, but some acpi_devices have multiple I2cSerialBus
 * resources, in that case this function can be used to create an i2c-client
 * for other I2cSerialBus resources in the Current Resource Settings table.
 *
 * Also see i2c_new_device, which this function calls to create the i2c-client.
 *
 * Returns a pointer to the new i2c-client, or NULL if the adapter is not found.
 */
struct i2c_client *i2c_acpi_new_device(struct device *dev, int index,
				       struct i2c_board_info *info)
{
	struct i2c_acpi_lookup lookup;
	struct i2c_adapter *adapter;
	struct acpi_device *adev;
	LIST_HEAD(resource_list);
	int ret;

	adev = ACPI_COMPANION(dev);
	if (!adev)
		return NULL;

	memset(&lookup, 0, sizeof(lookup));
	lookup.info = info;
	lookup.device_handle = acpi_device_handle(adev);
	lookup.index = index;

	ret = acpi_dev_get_resources(adev, &resource_list,
				     i2c_acpi_fill_info, &lookup);
	acpi_dev_free_resource_list(&resource_list);

	if (ret < 0 || !info->addr)
		return NULL;

	adapter = i2c_acpi_find_adapter_by_handle(lookup.adapter_handle);
	if (!adapter)
		return NULL;

	return i2c_new_device(adapter, info);
}
EXPORT_SYMBOL_GPL(i2c_acpi_new_device);
465
#else /* CONFIG_ACPI */
466
static inline void i2c_acpi_register_devices(struct i2c_adapter *adap) { }
467
extern struct notifier_block i2c_acpi_notifier;
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
#endif /* CONFIG_ACPI */

#ifdef CONFIG_ACPI_I2C_OPREGION
static int acpi_gsb_i2c_read_bytes(struct i2c_client *client,
		u8 cmd, u8 *data, u8 data_len)
{

	struct i2c_msg msgs[2];
	int ret;
	u8 *buffer;

	buffer = kzalloc(data_len, GFP_KERNEL);
	if (!buffer)
		return AE_NO_MEMORY;

	msgs[0].addr = client->addr;
	msgs[0].flags = client->flags;
	msgs[0].len = 1;
	msgs[0].buf = &cmd;

	msgs[1].addr = client->addr;
	msgs[1].flags = client->flags | I2C_M_RD;
	msgs[1].len = data_len;
	msgs[1].buf = buffer;

	ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
	if (ret < 0)
		dev_err(&client->adapter->dev, "i2c read failed\n");
	else
		memcpy(data, buffer, data_len);

	kfree(buffer);
	return ret;
}

static int acpi_gsb_i2c_write_bytes(struct i2c_client *client,
		u8 cmd, u8 *data, u8 data_len)
{

	struct i2c_msg msgs[1];
	u8 *buffer;
	int ret = AE_OK;

	buffer = kzalloc(data_len + 1, GFP_KERNEL);
	if (!buffer)
		return AE_NO_MEMORY;

	buffer[0] = cmd;
	memcpy(buffer + 1, data, data_len);

	msgs[0].addr = client->addr;
	msgs[0].flags = client->flags;
	msgs[0].len = data_len + 1;
	msgs[0].buf = buffer;

	ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
	if (ret < 0)
		dev_err(&client->adapter->dev, "i2c write failed\n");

	kfree(buffer);
	return ret;
}

static acpi_status
532
i2c_acpi_space_handler(u32 function, acpi_physical_address command,
533
534
535
536
			u32 bits, u64 *value64,
			void *handler_context, void *region_context)
{
	struct gsb_buffer *gsb = (struct gsb_buffer *)value64;
537
	struct i2c_acpi_handler_data *data = handler_context;
538
539
540
	struct acpi_connection_info *info = &data->info;
	struct acpi_resource_i2c_serialbus *sb;
	struct i2c_adapter *adapter = data->adapter;
541
	struct i2c_client *client;
542
543
544
	struct acpi_resource *ares;
	u32 accessor_type = function >> 16;
	u8 action = function & ACPI_IO_MASK;
545
	acpi_status ret;
546
547
548
549
550
551
	int status;

	ret = acpi_buffer_to_resource(info->connection, info->length, &ares);
	if (ACPI_FAILURE(ret))
		return ret;

552
553
554
555
556
557
	client = kzalloc(sizeof(*client), GFP_KERNEL);
	if (!client) {
		ret = AE_NO_MEMORY;
		goto err;
	}

558
559
560
561
562
563
564
565
566
567
568
	if (!value64 || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) {
		ret = AE_BAD_PARAMETER;
		goto err;
	}

	sb = &ares->data.i2c_serial_bus;
	if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) {
		ret = AE_BAD_PARAMETER;
		goto err;
	}

569
570
	client->adapter = adapter;
	client->addr = sb->slave_address;
571
572

	if (sb->access_mode == ACPI_I2C_10BIT_MODE)
573
		client->flags |= I2C_CLIENT_TEN;
574
575
576
577

	switch (accessor_type) {
	case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV:
		if (action == ACPI_READ) {
578
			status = i2c_smbus_read_byte(client);
579
580
581
582
583
			if (status >= 0) {
				gsb->bdata = status;
				status = 0;
			}
		} else {
584
			status = i2c_smbus_write_byte(client, gsb->bdata);
585
586
587
588
589
		}
		break;

	case ACPI_GSB_ACCESS_ATTRIB_BYTE:
		if (action == ACPI_READ) {
590
			status = i2c_smbus_read_byte_data(client, command);
591
592
593
594
595
			if (status >= 0) {
				gsb->bdata = status;
				status = 0;
			}
		} else {
596
			status = i2c_smbus_write_byte_data(client, command,
597
598
599
600
601
602
					gsb->bdata);
		}
		break;

	case ACPI_GSB_ACCESS_ATTRIB_WORD:
		if (action == ACPI_READ) {
603
			status = i2c_smbus_read_word_data(client, command);
604
605
606
607
608
			if (status >= 0) {
				gsb->wdata = status;
				status = 0;
			}
		} else {
609
			status = i2c_smbus_write_word_data(client, command,
610
611
612
613
614
615
					gsb->wdata);
		}
		break;

	case ACPI_GSB_ACCESS_ATTRIB_BLOCK:
		if (action == ACPI_READ) {
616
			status = i2c_smbus_read_block_data(client, command,
617
618
619
620
621
622
					gsb->data);
			if (status >= 0) {
				gsb->len = status;
				status = 0;
			}
		} else {
623
			status = i2c_smbus_write_block_data(client, command,
624
625
626
627
628
629
					gsb->len, gsb->data);
		}
		break;

	case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE:
		if (action == ACPI_READ) {
630
			status = acpi_gsb_i2c_read_bytes(client, command,
631
632
633
634
					gsb->data, info->access_length);
			if (status > 0)
				status = 0;
		} else {
635
			status = acpi_gsb_i2c_write_bytes(client, command,
636
637
638
639
640
					gsb->data, info->access_length);
		}
		break;

	default:
641
642
		dev_warn(&adapter->dev, "protocol 0x%02x not supported for client 0x%02x\n",
			 accessor_type, client->addr);
643
644
645
646
647
648
649
		ret = AE_BAD_PARAMETER;
		goto err;
	}

	gsb->status = status;

 err:
650
	kfree(client);
651
652
653
654
655
	ACPI_FREE(ares);
	return ret;
}


656
static int i2c_acpi_install_space_handler(struct i2c_adapter *adapter)
657
{
658
	acpi_handle handle;
659
	struct i2c_acpi_handler_data *data;
660
661
	acpi_status status;

662
663
664
665
666
	if (!adapter->dev.parent)
		return -ENODEV;

	handle = ACPI_HANDLE(adapter->dev.parent);

667
668
669
	if (!handle)
		return -ENODEV;

670
	data = kzalloc(sizeof(struct i2c_acpi_handler_data),
671
672
673
674
675
676
677
678
679
680
681
682
683
			    GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	data->adapter = adapter;
	status = acpi_bus_attach_private_data(handle, (void *)data);
	if (ACPI_FAILURE(status)) {
		kfree(data);
		return -ENOMEM;
	}

	status = acpi_install_address_space_handler(handle,
				ACPI_ADR_SPACE_GSBUS,
684
				&i2c_acpi_space_handler,
685
686
687
688
689
690
691
692
693
				NULL,
				data);
	if (ACPI_FAILURE(status)) {
		dev_err(&adapter->dev, "Error installing i2c space handler\n");
		acpi_bus_detach_private_data(handle);
		kfree(data);
		return -ENOMEM;
	}

694
	acpi_walk_dep_device_list(handle);
695
696
697
	return 0;
}

698
static void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter)
699
{
700
	acpi_handle handle;
701
	struct i2c_acpi_handler_data *data;
702
703
	acpi_status status;

704
705
706
707
708
	if (!adapter->dev.parent)
		return;

	handle = ACPI_HANDLE(adapter->dev.parent);

709
710
711
712
713
	if (!handle)
		return;

	acpi_remove_address_space_handler(handle,
				ACPI_ADR_SPACE_GSBUS,
714
				&i2c_acpi_space_handler);
715
716
717
718
719
720
721
722

	status = acpi_bus_get_private_data(handle, (void **)&data);
	if (ACPI_SUCCESS(status))
		kfree(data);

	acpi_bus_detach_private_data(handle);
}
#else /* CONFIG_ACPI_I2C_OPREGION */
723
static inline void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter)
724
725
{ }

726
static inline int i2c_acpi_install_space_handler(struct i2c_adapter *adapter)
727
728
729
{ return 0; }
#endif /* CONFIG_ACPI_I2C_OPREGION */

730
731
/* ------------------------------------------------------------------------- */

732
const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
733
734
						const struct i2c_client *client)
{
735
736
737
	if (!(id && client))
		return NULL;

738
739
740
741
742
743
744
	while (id->name[0]) {
		if (strcmp(client->name, id->name) == 0)
			return id;
		id++;
	}
	return NULL;
}
745
EXPORT_SYMBOL_GPL(i2c_match_id);
746

Linus Torvalds's avatar
Linus Torvalds committed
747
748
static int i2c_device_match(struct device *dev, struct device_driver *drv)
{
749
750
751
	struct i2c_client	*client = i2c_verify_client(dev);
	struct i2c_driver	*driver;

David Brownell's avatar
David Brownell committed
752

753
	/* Attempt an OF style match */
754
	if (i2c_of_match_device(drv->of_match_table, client))
755
756
		return 1;

757
758
759
760
	/* Then ACPI style match */
	if (acpi_driver_match_device(dev, drv))
		return 1;

761
	driver = to_i2c_driver(drv);
762
763
764
765

	/* Finally an I2C match */
	if (i2c_match_id(driver->id_table, client))
		return 1;
766

767
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
768
769
}

770
static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
David Brownell's avatar
David Brownell committed
771
{
772
	struct i2c_client *client = to_i2c_client(dev);
773
774
775
776
777
	int rc;

	rc = acpi_device_uevent_modalias(dev, env);
	if (rc != -ENODEV)
		return rc;
David Brownell's avatar
David Brownell committed
778

779
	return add_uevent_var(env, "MODALIAS=%s%s", I2C_MODULE_PREFIX, client->name);
David Brownell's avatar
David Brownell committed
780
781
}

782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
/* i2c bus recovery routines */
static int get_scl_gpio_value(struct i2c_adapter *adap)
{
	return gpio_get_value(adap->bus_recovery_info->scl_gpio);
}

static void set_scl_gpio_value(struct i2c_adapter *adap, int val)
{
	gpio_set_value(adap->bus_recovery_info->scl_gpio, val);
}

static int get_sda_gpio_value(struct i2c_adapter *adap)
{
	return gpio_get_value(adap->bus_recovery_info->sda_gpio);
}

static int i2c_get_gpios_for_recovery(struct i2c_adapter *adap)
{
	struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
	struct device *dev = &adap->dev;
	int ret = 0;

	ret = gpio_request_one(bri->scl_gpio, GPIOF_OPEN_DRAIN |
			GPIOF_OUT_INIT_HIGH, "i2c-scl");
	if (ret) {
		dev_warn(dev, "Can't get SCL gpio: %d\n", bri->scl_gpio);
		return ret;
	}

	if (bri->get_sda) {
		if (gpio_request_one(bri->sda_gpio, GPIOF_IN, "i2c-sda")) {
			/* work without SDA polling */
			dev_warn(dev, "Can't get SDA gpio: %d. Not using SDA polling\n",
					bri->sda_gpio);
			bri->get_sda = NULL;
		}
	}

	return ret;
}

static void i2c_put_gpios_for_recovery(struct i2c_adapter *adap)
{
	struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;

	if (bri->get_sda)
		gpio_free(bri->sda_gpio);

	gpio_free(bri->scl_gpio);
}

/*
 * We are generating clock pulses. ndelay() determines durating of clk pulses.
 * We will generate clock with rate 100 KHz and so duration of both clock levels
 * is: delay in ns = (10^6 / 100) / 2
 */
#define RECOVERY_NDELAY		5000
#define RECOVERY_CLK_CNT	9

static int i2c_generic_recovery(struct i2c_adapter *adap)
{
	struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
	int i = 0, val = 1, ret = 0;

	if (bri->prepare_recovery)
847
		bri->prepare_recovery(adap);
848

849
850
851
	bri->set_scl(adap, val);
	ndelay(RECOVERY_NDELAY);

852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
	/*
	 * By this time SCL is high, as we need to give 9 falling-rising edges
	 */
	while (i++ < RECOVERY_CLK_CNT * 2) {
		if (val) {
			/* Break if SDA is high */
			if (bri->get_sda && bri->get_sda(adap))
					break;
			/* SCL shouldn't be low here */
			if (!bri->get_scl(adap)) {
				dev_err(&adap->dev,
					"SCL is stuck low, exit recovery\n");
				ret = -EBUSY;
				break;
			}
		}

		val = !val;
		bri->set_scl(adap, val);
		ndelay(RECOVERY_NDELAY);
	}

	if (bri->unprepare_recovery)
875
		bri->unprepare_recovery(adap);
876
877
878
879
880
881
882
883

	return ret;
}

int i2c_generic_scl_recovery(struct i2c_adapter *adap)
{
	return i2c_generic_recovery(adap);
}
884
EXPORT_SYMBOL_GPL(i2c_generic_scl_recovery);
885
886
887
888
889
890
891
892
893
894
895
896
897
898

int i2c_generic_gpio_recovery(struct i2c_adapter *adap)
{
	int ret;

	ret = i2c_get_gpios_for_recovery(adap);
	if (ret)
		return ret;

	ret = i2c_generic_recovery(adap);
	i2c_put_gpios_for_recovery(adap);

	return ret;
}
899
EXPORT_SYMBOL_GPL(i2c_generic_gpio_recovery);
900
901
902
903
904
905
906
907
908

int i2c_recover_bus(struct i2c_adapter *adap)
{
	if (!adap->bus_recovery_info)
		return -EOPNOTSUPP;

	dev_dbg(&adap->dev, "Trying i2c bus recovery\n");
	return adap->bus_recovery_info->recover_bus(adap);
}
909
EXPORT_SYMBOL_GPL(i2c_recover_bus);
910

911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
static void i2c_init_recovery(struct i2c_adapter *adap)
{
	struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
	char *err_str;

	if (!bri)
		return;

	if (!bri->recover_bus) {
		err_str = "no recover_bus() found";
		goto err;
	}

	/* Generic GPIO recovery */
	if (bri->recover_bus == i2c_generic_gpio_recovery) {
		if (!gpio_is_valid(bri->scl_gpio)) {
			err_str = "invalid SCL gpio";
			goto err;
		}

		if (gpio_is_valid(bri->sda_gpio))
			bri->get_sda = get_sda_gpio_value;
		else
			bri->get_sda = NULL;

		bri->get_scl = get_scl_gpio_value;
		bri->set_scl = set_scl_gpio_value;
	} else if (bri->recover_bus == i2c_generic_scl_recovery) {
		/* Generic SCL recovery */
		if (!bri->set_scl || !bri->get_scl) {
			err_str = "no {get|set}_scl() found";
			goto err;
		}
	}

	return;
 err:
	dev_err(&adap->dev, "Not using recovery: %s\n", err_str);
	adap->bus_recovery_info = NULL;
}

952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
static int i2c_smbus_host_notify_to_irq(const struct i2c_client *client)
{
	struct i2c_adapter *adap = client->adapter;
	unsigned int irq;

	if (!adap->host_notify_domain)
		return -ENXIO;

	if (client->flags & I2C_CLIENT_TEN)
		return -EINVAL;

	irq = irq_find_mapping(adap->host_notify_domain, client->addr);
	if (!irq)
		irq = irq_create_mapping(adap->host_notify_domain,
					 client->addr);

	return irq > 0 ? irq : -ENXIO;
}

971
static int i2c_device_probe(struct device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
972
{
973
974
	struct i2c_client	*client = i2c_verify_client(dev);
	struct i2c_driver	*driver;
975
	int status;
David Brownell's avatar
David Brownell committed
976

977
978
979
	if (!client)
		return 0;

980
981
982
	driver = to_i2c_driver(dev->driver);

	if (!client->irq && !driver->disable_i2c_core_irq_mapping) {
983
984
		int irq = -ENOENT;

985
986
987
988
		if (client->flags & I2C_CLIENT_HOST_NOTIFY) {
			dev_dbg(dev, "Using Host Notify IRQ\n");
			irq = i2c_smbus_host_notify_to_irq(client);
		} else if (dev->of_node) {
989
990
991
992
			irq = of_irq_get_byname(dev->of_node, "irq");
			if (irq == -EINVAL || irq == -ENODATA)
				irq = of_irq_get(dev->of_node, 0);
		} else if (ACPI_COMPANION(dev)) {
993
			irq = acpi_dev_gpio_irq_get(ACPI_COMPANION(dev), 0);
994
		}
995
		if (irq == -EPROBE_DEFER)
996
			return irq;
997

998
999
		if (irq < 0)
			irq = 0;
1000
1001
1002
1003

		client->irq = irq;
	}

1004
1005
1006
1007
1008
1009
	/*
	 * An I2C ID table is not mandatory, if and only if, a suitable Device
	 * Tree match table entry is supplied for the probing device.
	 */
	if (!driver->id_table &&
	    !i2c_of_match_device(dev->driver->of_match_table, client))
David Brownell's avatar
David Brownell committed
1010
		return -ENODEV;
1011

1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
	if (client->flags & I2C_CLIENT_WAKE) {
		int wakeirq = -ENOENT;

		if (dev->of_node) {
			wakeirq = of_irq_get_byname(dev->of_node, "wakeup");
			if (wakeirq == -EPROBE_DEFER)
				return wakeirq;
		}

		device_init_wakeup(&client->dev, true);

		if (wakeirq > 0 && wakeirq != client->irq)
			status = dev_pm_set_dedicated_wake_irq(dev, wakeirq);
		else if (client->irq > 0)
1026
			status = dev_pm_set_wake_irq(dev, client->irq);
1027
1028
1029
1030
		else
			status = 0;

		if (status)
1031
			dev_warn(&client->dev, "failed to set up wakeup irq\n");
1032
1033
	}

David Brownell's avatar
David Brownell committed
1034
	dev_dbg(dev, "probe\n");
1035

1036
1037
	status = of_clk_set_defaults(dev->of_node, false);
	if (status < 0)
1038
		goto err_clear_wakeup_irq;
1039

1040
	status = dev_pm_domain_attach(&client->dev, true);
1041
1042
1043
	if (status == -EPROBE_DEFER)
		goto err_clear_wakeup_irq;

1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
	/*
	 * When there are no more users of probe(),
	 * rename probe_new to probe.
	 */
	if (driver->probe_new)
		status = driver->probe_new(client);
	else if (driver->probe)
		status = driver->probe(client,
				       i2c_match_id(driver->id_table, client));
	else
		status = -EINVAL;

1056
1057
	if (status)
		goto err_detach_pm_domain;
1058

1059
1060
1061
1062
1063
1064
1065
	return 0;

err_detach_pm_domain:
	dev_pm_domain_detach(&client->dev, true);
err_clear_wakeup_irq:
	dev_pm_clear_wake_irq(&client->dev);
	device_init_wakeup(&client->dev, false);
1066
	return status;
1067
}
Linus Torvalds's avatar
Linus Torvalds committed
1068

1069
1070
static int i2c_device_remove(struct device *dev)
{
1071
	struct i2c_client	*client = i2c_verify_client(dev);
David Brownell's avatar
David Brownell committed
1072
	struct i2c_driver	*driver;
1073
	int status = 0;
David Brownell's avatar
David Brownell committed
1074

1075
	if (!client || !dev->driver)
David Brownell's avatar
David Brownell committed
1076
1077
1078
1079
1080
1081
1082
		return 0;

	driver = to_i2c_driver(dev->driver);
	if (driver->remove) {
		dev_dbg(dev, "remove\n");
		status = driver->remove(client);
	}
1083

1084
	dev_pm_domain_detach(&client->dev, true);
1085
1086
1087
1088

	dev_pm_clear_wake_irq(&client->dev);
	device_init_wakeup(&client->dev, false);

David Brownell's avatar
David Brownell committed
1089
	return status;
Linus Torvalds's avatar
Linus Torvalds committed
1090
1091
}

1092
static void i2c_device_shutdown(struct device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
1093
{
1094
	struct i2c_client *client = i2c_verify_client(dev);
1095
1096
	struct i2c_driver *driver;

1097
	if (!client || !dev->driver)
1098
1099
1100
		return;
	driver = to_i2c_driver(dev->driver);
	if (driver->shutdown)
1101
		driver->shutdown(client);
Linus Torvalds's avatar
Linus Torvalds committed
1102
1103
}

1104
1105
1106
1107
1108
static void i2c_client_dev_release(struct device *dev)
{
	kfree(to_i2c_client(dev));
}

Zhenwen Xu's avatar
Zhenwen Xu committed
1109
static ssize_t
1110
show_name(struct device *dev, struct device_attribute *attr, char *buf)
David Brownell's avatar
David Brownell committed
1111
{
1112
1113
	return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
		       to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
David Brownell's avatar
David Brownell committed
1114
}
1115
static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
David Brownell's avatar
David Brownell committed
1116

Zhenwen Xu's avatar
Zhenwen Xu committed
1117
1118
static ssize_t
show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
David Brownell's avatar
David Brownell committed
1119
1120
{
	struct i2c_client *client = to_i2c_client(dev);
1121
1122
1123
1124
1125
1126
	int len;

	len = acpi_device_modalias(dev, buf, PAGE_SIZE -1);
	if (len != -ENODEV)
		return len;

1127
	return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
David Brownell's avatar
David Brownell committed
1128
}
1129
1130
1131
1132
static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);

static struct attribute *i2c_dev_attrs[] = {
	&dev_attr_name.attr,
David Brownell's avatar
David Brownell committed
1133
	/* modalias helps coldplug:  modprobe $(cat .../modalias) */
1134
1135
1136
	&dev_attr_modalias.attr,
	NULL
};
1137
ATTRIBUTE_GROUPS(i2c_dev);
1138

1139
struct bus_type i2c_bus_type = {
1140
1141
1142
1143
1144
	.name		= "i2c",
	.match		= i2c_device_match,
	.probe		= i2c_device_probe,
	.remove		= i2c_device_remove,
	.shutdown	= i2c_device_shutdown,
1145
};
1146
EXPORT_SYMBOL_GPL(i2c_bus_type);
1147

1148
struct device_type i2c_client_type = {
1149
	.groups		= i2c_dev_groups,
1150
1151
1152
	.uevent		= i2c_device_uevent,
	.release	= i2c_client_dev_release,
};
1153
EXPORT_SYMBOL_GPL(i2c_client_type);
1154

1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166

/**
 * i2c_verify_client - return parameter as i2c_client, or NULL
 * @dev: device, probably from some driver model iterator
 *
 * When traversing the driver model tree, perhaps using driver model
 * iterators like @device_for_each_child(), you can't assume very much
 * about the nodes you find.  Use this function to avoid oopses caused
 * by wrongly treating some non-I2C device as an i2c_client.
 */
struct i2c_client *i2c_verify_client(struct device *dev)
{
1167
	return (dev->type == &i2c_client_type)
1168
1169
1170
1171
1172
1173
			? to_i2c_client(dev)
			: NULL;
}
EXPORT_SYMBOL(i2c_verify_client);


1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
/* Return a unique address which takes the flags of the client into account */
static unsigned short i2c_encode_flags_to_addr(struct i2c_client *client)
{
	unsigned short addr = client->addr;

	/* For some client flags, add an arbitrary offset to avoid collisions */
	if (client->flags & I2C_CLIENT_TEN)
		addr |= I2C_ADDR_OFFSET_TEN_BIT;

	if (client->flags & I2C_CLIENT_SLAVE)
		addr |= I2C_ADDR_OFFSET_SLAVE;

	return addr;
}

1189
/* This is a permissive address validity check, I2C address map constraints
Lucas De Marchi's avatar
Lucas De Marchi committed
1190
 * are purposely not enforced, except for the general call address. */
1191
int i2c_check_addr_validity(unsigned addr, unsigned short flags)
1192
{
1193
	if (flags & I2C_CLIENT_TEN) {
1194
		/* 10-bit address, all values are valid */
1195
		if (addr > 0x3ff)
1196
1197
1198
			return -EINVAL;
	} else {
		/* 7-bit address, reject the general call address */
1199
		if (addr == 0x00 || addr > 0x7f)
1200
1201
1202
1203
1204
			return -EINVAL;
	}
	return 0;
}

1205
1206
1207
1208
/* And this is a strict address validity check, used when probing. If a
 * device uses a reserved address, then it shouldn't be probed. 7-bit
 * addressing is assumed, 10-bit address devices are rare and should be
 * explicitly enumerated. */
1209
int i2c_check_7bit_addr_validity_strict(unsigned short addr)
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
{
	/*
	 * Reserved addresses per I2C specification:
	 *  0x00       General call address / START byte
	 *  0x01       CBUS address
	 *  0x02       Reserved for different bus format
	 *  0x03       Reserved for future purposes
	 *  0x04-0x07  Hs-mode master code
	 *  0x78-0x7b  10-bit slave addressing
	 *  0x7c-0x7f  Reserved for future purposes
	 */
	if (addr < 0x08 || addr > 0x77)
		return -EINVAL;
	return 0;
}

1226
1227
1228
1229
1230
static int __i2c_check_addr_busy(struct device *dev, void *addrp)
{
	struct i2c_client	*client = i2c_verify_client(dev);
	int			addr = *(int *)addrp;

1231
	if (client && i2c_encode_flags_to_addr(client) == addr)
1232
1233
1234
1235
		return -EBUSY;
	return 0;
}

1236
1237
1238
/* walk up mux tree */
static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
{
1239
	struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
1240
1241
1242
1243
1244
	int result;

	result = device_for_each_child(&adapter->dev, &addr,
					__i2c_check_addr_busy);

1245
1246
	if (!result && parent)
		result = i2c_check_mux_parents(parent, addr);
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264

	return result;
}

/* recurse down mux tree */
static int i2c_check_mux_children(struct device *dev, void *addrp)
{
	int result;

	if (dev->type == &i2c_adapter_type)
		result = device_for_each_child(dev, addrp,
						i2c_check_mux_children);
	else
		result = __i2c_check_addr_busy(dev, addrp);

	return result;
}

1265
1266
static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
{
1267
	struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
1268
1269
	int result =