Release 4.11 drivers/i2c/i2c-core.c

/* 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
    GNU General Public License for more details.                             */
/* ------------------------------------------------------------------------- */

/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>.
   All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl>
   SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and
   Jean Delvare <jdelvare@suse.de>
   Mux support by Rodolfo Giometti <giometti@enneenne.com> and
   Michael Lawnick <michael.lawnick.ext@nsn.com>
   OF support is copyright (c) 2008 Jochen Friedrich <jochen@scram.de>
   (based on a previous patch from Jon Smirl <jonsmirl@gmail.com>) and
   (c) 2013  Wolfram Sang <wsa@the-dreams.de>
   I2C ACPI code Copyright (C) 2014 Intel Corp
   Author: Lan Tianyu <tianyu.lan@intel.com>
   I2C slave support (c) 2014 by Wolfram Sang <wsa@sang-engineering.com>
 */


#define pr_fmt(fmt) "i2c-core: " fmt

#include <dt-bindings/i2c/i2c.h>
#include <linux/uaccess.h>
#include <linux/acpi.h>
#include <linux/clk/clk-conf.h>
#include <linux/completion.h>
#include <linux/delay.h>
#include <linux/err.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/hardirq.h>
#include <linux/i2c.h>
#include <linux/idr.h>
#include <linux/init.h>
#include <linux/irqflags.h>
#include <linux/jump_label.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/of_device.h>
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/pm_domain.h>
#include <linux/pm_runtime.h>
#include <linux/pm_wakeirq.h>
#include <linux/property.h>
#include <linux/rwsem.h>
#include <linux/slab.h>

#include "i2c-core.h"


#define CREATE_TRACE_POINTS
#include <trace/events/i2c.h>


#define I2C_ADDR_OFFSET_TEN_BIT	0xa000

#define I2C_ADDR_OFFSET_SLAVE	0x1000


#define I2C_ADDR_7BITS_MAX	0x77

#define I2C_ADDR_7BITS_COUNT	(I2C_ADDR_7BITS_MAX + 1)

/* core_lock protects i2c_adapter_idr, and guarantees
   that device detection, deletion of detected devices, and attach_adapter
   calls are serialized */
static DEFINE_MUTEX(core_lock);
static DEFINE_IDR(i2c_adapter_idr);


static struct device_type i2c_client_type;
static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);


static struct static_key i2c_trace_msg = STATIC_KEY_INIT_FALSE;

static bool is_registered;



int i2c_transfer_trace_reg(void)
{
	static_key_slow_inc(&i2c_trace_msg);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David Howells
12
75.00%
1
50.00%
Steven Rostedt
4
25.00%
1
50.00%
Total
16
100.00%
2
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
David Howells
13
100.00%
1
100.00%
Total
13
100.00%
1
100.00%

#if defined(CONFIG_ACPI)

struct i2c_acpi_handler_data {
	
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;


struct i2c_acpi_lookup {
	
struct i2c_board_info *info;
	
acpi_handle adapter_handle;
	
acpi_handle device_handle;
	
acpi_handle search_handle;
	
u32 speed;
	
u32 min_speed;
};



static int i2c_acpi_fill_info(struct acpi_resource *ares, void *data)
{
	struct i2c_acpi_lookup *lookup = data;
	struct i2c_board_info *info = lookup->info;
	struct acpi_resource_i2c_serialbus *sb;
	acpi_status status;

	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;

	status = acpi_get_handle(lookup->device_handle,
				 sb->resource_source.string_ptr,
				 &lookup->adapter_handle);
	if (!ACPI_SUCCESS(status))
		return 1;

	info->addr = sb->slave_address;
	lookup->speed = sb->connection_speed;
	if (sb->access_mode == ACPI_I2C_10BIT_MODE)
		info->flags |= I2C_CLIENT_TEN;

	return 1;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Wolfram Sang
68
49.28%
1
20.00%
Mika Westerberg
54
39.13%
1
20.00%
Jarkko Nikula
10
7.25%
2
40.00%
Octavian Purdila
6
4.35%
1
20.00%
Total
138
100.00%
5
100.00%



static int i2c_acpi_do_lookup(struct acpi_device *adev,
			      struct i2c_acpi_lookup *lookup)
{
	struct i2c_board_info *info = lookup->info;
	struct list_head resource_list;
	int ret;

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

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

	/* Look up for I2cSerialBus resource */
	INIT_LIST_HEAD(&resource_list);
	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 -EINVAL;

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Wolfram Sang
76
62.30%
1
20.00%
Octavian Purdila
20
16.39%
1
20.00%
Jarkko Nikula
17
13.93%
2
40.00%
Mika Westerberg
9
7.38%
1
20.00%
Total
122
100.00%
5
100.00%



static int i2c_acpi_get_info(struct acpi_device *adev,
			     struct i2c_board_info *info,
			     struct i2c_adapter *adapter,
			     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;

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

	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;
	}

	info->fwnode = acpi_fwnode_handle(adev);
	if (adapter_handle)
		*adapter_handle = lookup.adapter_handle;

	/* Then fill IRQ number if any */
	INIT_LIST_HEAD(&resource_list);
	ret = acpi_dev_get_resources(adev, &resource_list, NULL, NULL);
	if (ret < 0)
		return -EINVAL;

	resource_list_for_each_entry(entry, &resource_list) {
		if (resource_type(entry->res) == IORESOURCE_IRQ) {
			info->irq = entry->res->start;
			break;
		}
	}

	acpi_dev_free_resource_list(&resource_list);

	acpi_set_modalias(adev, dev_name(&adev->dev), info->type,
			  sizeof(info->type));

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Mika Westerberg
94
36.02%
2
40.00%
Jarkko Nikula
86
32.95%
1
20.00%
Octavian Purdila
75
28.74%
1
20.00%
Dan O'Donovan
6
2.30%
1
20.00%
Total
261
100.00%
5
100.00%



static void i2c_acpi_register_device(struct i2c_adapter *adapter,
				     struct acpi_device *adev,
				     struct i2c_board_info *info)
{
	adev->power.flags.ignore_parent = true;
	acpi_device_set_enumerated(adev);

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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Octavian Purdila
75
98.68%
1
50.00%
Jarkko Nikula
1
1.32%
1
50.00%
Total
76
100.00%
2
100.00%



static acpi_status i2c_acpi_add_device(acpi_handle handle, u32 level,
				       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;

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

	i2c_acpi_register_device(adapter, adev, &info);

	return AE_OK;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Octavian Purdila
75
93.75%
1
33.33%
Jarkko Nikula
3
3.75%
1
33.33%
Mika Westerberg
2
2.50%
1
33.33%
Total
80
100.00%
3
100.00%


#define I2C_ACPI_MAX_SCAN_DEPTH 32

/**
 * i2c_acpi_register_devices - enumerate I2C slave devices behind adapter
 * @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.
 */


static void i2c_acpi_register_devices(struct i2c_adapter *adap)
{
	acpi_status status;

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

	status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
				     I2C_ACPI_MAX_SCAN_DEPTH,
				     i2c_acpi_add_device, NULL,
				     adap, NULL);
	if (ACPI_FAILURE(status))
		dev_warn(&adap->dev, "failed to enumerate I2C slaves\n");
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Octavian Purdila
59
95.16%
1
50.00%
Jarkko Nikula
3
4.84%
1
50.00%
Total
62
100.00%
2
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jarkko Nikula
92
100.00%
1
100.00%
Total
92
100.00%
1
100.00%

/**
 * 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;

	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;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jarkko Nikula
119
100.00%
1
100.00%
Total
119
100.00%
1
100.00%


EXPORT_SYMBOL_GPL(i2c_acpi_find_bus_speed);



static int i2c_acpi_match_adapter(struct device *dev, void *data)
{
	struct i2c_adapter *adapter = i2c_verify_adapter(dev);

	if (!adapter)
		return 0;

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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Octavian Purdila
43
97.73%
1
50.00%
Jarkko Nikula
1
2.27%
1
50.00%
Total
44
100.00%
2
100.00%



static int i2c_acpi_match_device(struct device *dev, void *data)
{
	return ACPI_COMPANION(dev) == data;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Octavian Purdila
22
95.65%
1
50.00%
Jarkko Nikula
1
4.35%
1
50.00%
Total
23
100.00%
2
100.00%



static struct i2c_adapter *i2c_acpi_find_adapter_by_handle(acpi_handle handle)
{
	struct device *dev;

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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Octavian Purdila
38
95.00%
1
50.00%
Jarkko Nikula
2
5.00%
1
50.00%
Total
40
100.00%
2
100.00%



static struct i2c_client *i2c_acpi_find_client_by_adev(struct acpi_device *adev)
{
	struct device *dev;

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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Octavian Purdila
40
95.24%
1
50.00%
Jarkko Nikula
2
4.76%
1
50.00%
Total
42
100.00%
2
100.00%



static int i2c_acpi_notify(struct notifier_block *nb, unsigned long value,
			   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:
		if (i2c_acpi_get_info(adev, &info, NULL, &adapter_handle))
			break;

		adapter = i2c_acpi_find_adapter_by_handle(adapter_handle);
		if (!adapter)
			break;

		i2c_acpi_register_device(adapter, adev, &info);
		break;
	case ACPI_RECONFIG_DEVICE_REMOVE:
		if (!acpi_device_enumerated(adev))
			break;

		client = i2c_acpi_find_client_by_adev(adev);
		if (!client)
			break;

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

	return NOTIFY_OK;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Octavian Purdila
81
60.45%
1
20.00%
Wolfram Sang
41
30.60%
1
20.00%
Mika Westerberg
7
5.22%
2
40.00%
Jarkko Nikula
5
3.73%
1
20.00%
Total
134
100.00%
5
100.00%


static struct notifier_block i2c_acpi_notifier = {
	.notifier_call = i2c_acpi_notify,
};
#else /* CONFIG_ACPI */


static inline void i2c_acpi_register_devices(struct i2c_adapter *adap) { }
Contributors
Person
Tokens
Prop
Commits
CommitProp
Wolfram Sang
10
90.91%
1
50.00%
Jarkko Nikula
1
9.09%
1
50.00%
Total
11
100.00%
2
100.00%

extern struct notifier_block i2c_acpi_notifier;
#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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Wolfram Sang
187
100.00%
1
100.00%
Total
187
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Wolfram Sang
158
100.00%
1
100.00%
Total
158
100.00%
1
100.00%


static acpi_status

i2c_acpi_space_handler(u32 function, acpi_physical_address command,
			u32 bits, u64 *value64,
			void *handler_context, void *region_context)
{
	struct gsb_buffer *gsb = (struct gsb_buffer *)value64;
	struct i2c_acpi_handler_data *data = handler_context;
	struct acpi_connection_info *info = &data->info;
	struct acpi_resource_i2c_serialbus *sb;
	struct i2c_adapter *adapter = data->adapter;
	struct i2c_client *client;
	struct acpi_resource *ares;
	u32 accessor_type = function >> 16;
	u8 action = function & ACPI_IO_MASK;
	acpi_status ret;
	int status;

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

	client = kzalloc(sizeof(*client), GFP_KERNEL);
	if (!client) {
		ret = AE_NO_MEMORY;
		goto err;
	}

	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;
	}

	client->adapter = adapter;
	client->addr = sb->slave_address;

	if (sb->access_mode == ACPI_I2C_10BIT_MODE)
		client->flags |= I2C_CLIENT_TEN;

	switch (accessor_type) {
	case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV:
		if (action == ACPI_READ) {
			status = i2c_smbus_read_byte(client);
			if (status >= 0) {
				gsb->bdata = status;
				status = 0;
			}
		} else {
			status = i2c_smbus_write_byte(client, gsb->bdata);
		}
		break;

	case ACPI_GSB_ACCESS_ATTRIB_BYTE:
		if (action == ACPI_READ) {
			status = i2c_smbus_read_byte_data(client, command);
			if (status >= 0) {
				gsb->bdata = status;
				status = 0;
			}
		} else {
			status = i2c_smbus_write_byte_data(client, command,
					gsb->bdata);
		}
		break;

	case ACPI_GSB_ACCESS_ATTRIB_WORD:
		if (action == ACPI_READ) {
			status = i2c_smbus_read_word_data(client, command);
			if (status >= 0) {
				gsb->wdata = status;
				status = 0;
			}
		} else {
			status = i2c_smbus_write_word_data(client, command,
					gsb->wdata);
		}
		break;

	case ACPI_GSB_ACCESS_ATTRIB_BLOCK:
		if (action == ACPI_READ) {
			status = i2c_smbus_read_block_data(client, command,
					gsb->data);
			if (status >= 0) {
				gsb->len = status;
				status = 0;
			}
		} else {
			status = i2c_smbus_write_block_data(client, command,
					gsb->len, gsb->data);
		}
		break;

	case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE:
		if (action == ACPI_READ) {
			status = acpi_gsb_i2c_read_bytes(client, command,
					gsb->data, info->access_length);
			if (status > 0)
				status = 0;
		} else {
			status = acpi_gsb_i2c_write_bytes(client, command,
					gsb->data, info->access_length);
		}
		break;

	default:
		dev_warn(&adapter->dev, "protocol 0x%02x not supported for client 0x%02x\n",
			 accessor_type, client->addr);
		ret = AE_BAD_PARAMETER;
		goto err;
	}

	gsb->status = status;

 err:
	kfree(client);
	ACPI_FREE(ares);
	return ret;
}


Contributors
Person
Tokens
Prop
Commits
CommitProp
Wolfram Sang
523
93.23%
2
50.00%
Jarkko Nikula
38
6.77%
2
50.00%
Total
561
100.00%
4
100.00%



static int i2c_acpi_install_space_handler(struct i2c_adapter *adapter)
{
	acpi_handle handle;
	struct i2c_acpi_handler_data *data;
	acpi_status status;

	if (!adapter->dev.parent)
		return -ENODEV;

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

	if (!handle)
		return -ENODEV;

	data = kzalloc(sizeof(struct i2c_acpi_handler_data),
			    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,
				&i2c_acpi_space_handler,
				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;
	}

	acpi_walk_dep_device_list(handle);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Wolfram Sang
138
80.70%
1
25.00%
Peter Hüwe
24
14.04%
1
25.00%
Lan Tianyu
5
2.92%
1
25.00%
Jarkko Nikula
4
2.34%
1
25.00%
Total
171
100.00%
4
100.00%



static void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter)
{
	acpi_handle handle;
	struct i2c_acpi_handler_data *data;
	acpi_status status;

	if (!adapter->dev.parent)
		return;

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

	if (!handle)
		return;

	acpi_remove_address_space_handler(handle,
				ACPI_ADR_SPACE_GSBUS,
				&i2c_acpi_space_handler);

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

	acpi_bus_detach_private_data(handle);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Wolfram Sang
67
73.63%
1
33.33%
Peter Hüwe
21
23.08%
1
33.33%
Jarkko Nikula
3
3.30%
1
33.33%
Total
91
100.00%
3
100.00%

#else /* CONFIG_ACPI_I2C_OPREGION */


static inline void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter)
{ }

Contributors
Person
Tokens
Prop
Commits
CommitProp
Wolfram Sang
10
90.91%
1
50.00%
Jarkko Nikula
1
9.09%
1
50.00%
Total
11
100.00%
2
100.00%



static inline int i2c_acpi_install_space_handler(struct i2c_adapter *adapter)
{ return 0; }
Contributors
Person
Tokens
Prop
Commits
CommitProp
Wolfram Sang
14
93.33%
1
50.00%
Jarkko Nikula
1
6.67%
1
50.00%
Total
15
100.00%
2
100.00%

#endif /* CONFIG_ACPI_I2C_OPREGION */

/* ------------------------------------------------------------------------- */



const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
						const struct i2c_client *client)
{
	if (!(id && client))
		return NULL;

	while (id->name[0]) {
		if (strcmp(client->name, id->name) == 0)
			return id;
		id++;
	}
	return NULL;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
55
82.09%
1
50.00%
Lee Jones
12
17.91%
1
50.00%
Total
67
100.00%
2
100.00%


EXPORT_SYMBOL_GPL(i2c_match_id);



static int i2c_device_match(struct device *dev, struct device_driver *drv)
{
	struct i2c_client	*client = i2c_verify_client(dev);
	struct i2c_driver	*driver;


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

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

	driver = to_i2c_driver(drv);

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

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David Brownell
21
25.00%
1
12.50%
Jean Delvare
16
19.05%
2
25.00%
Adrian Bunk
15
17.86%
1
12.50%
Mika Westerberg
13
15.48%
1
12.50%
Grant C. Likely
10
11.90%
1
12.50%
Lee Jones
9
10.71%
2
25.00%
Total
84
100.00%
8
100.00%



static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
{
	struct i2c_client *client = to_i2c_client(dev);
	int rc;

	rc = acpi_device_uevent_modalias(dev, env);
	if (rc != -ENODEV)
		return rc;

	return add_uevent_var(env, "MODALIAS=%s%s", I2C_MODULE_PREFIX, client->name);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Rui Zhang
22
35.48%
1
16.67%
David Brownell
22
35.48%
1
16.67%
Jean Delvare
12
19.35%
1
16.67%
Kay Sievers
3
4.84%
1
16.67%
Adrian Bunk
2
3.23%
1
16.67%
Wolfram Sang
1
1.61%
1
16.67%
Total
62
100.00%
6
100.00%

/* i2c bus recovery routines */


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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Viresh Kumar
21
100.00%
1
100.00%
Total
21
100.00%
1
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Viresh Kumar
25
100.00%
1
100.00%
Total
25
100.00%
1
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Viresh Kumar
21
100.00%
1
100.00%
Total
21
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Viresh Kumar
114
100.00%
1
100.00%
Total
114
100.00%
1
100.00%



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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Viresh Kumar
40
100.00%
1
100.00%
Total
40
100.00%
1
100.00%

/*
 * 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)
		bri->prepare_recovery(adap);

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

	/*
         * 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)
		bri->unprepare_recovery(adap);

	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Viresh Kumar
141
89.81%
1
33.33%
Jan Lübbe
14
8.92%
1
33.33%
Grygorii Strashko
2
1.27%
1
33.33%
Total
157
100.00%
3
100.00%



int i2c_generic_scl_recovery(struct i2c_adapter *adap)
{
	return i2c_generic_recovery(adap);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Viresh Kumar
16
100.00%
1
100.00%
Total
16
100.00%
1
100.00%


EXPORT_SYMBOL_GPL(i2c_generic_scl_recovery);



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;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Viresh Kumar
42
100.00%
1
100.00%
Total
42
100.00%
1
100.00%


EXPORT_SYMBOL_GPL(i2c_generic_gpio_recovery);



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);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Viresh Kumar
41
100.00%
1
100.00%
Total
41
100.00%
1
100.00%


EXPORT_SYMBOL_GPL(i2c_recover_bus);



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Wolfram Sang
164
100.00%
1
100.00%
Total
164
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Benjamin Tissoires
89
100.00%
1
100.00%
Total
89
100.00%
1
100.00%



static int i2c_device_probe(struct device *dev)
{
	struct i2c_client	*client = i2c_verify_client(dev);
	struct i2c_driver	*driver;
	int status;

	if (!client)
		return 0;

	if (!client->irq) {
		int irq = -ENOENT;

		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) {
			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)) {
			irq = acpi_dev_gpio_irq_get(ACPI_COMPANION(dev), 0);
		}
		if (irq == -EPROBE_DEFER)
			return irq;

		if (irq < 0)
			irq = 0;

		client->irq = irq;
	}

	driver = to_i2c_driver(dev->driver);

	/*
         * 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))
		return -ENODEV;

	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)
			status = dev_pm_set_wake_irq(dev, client->irq);
		else
			status = 0;

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

	dev_dbg(dev, "probe\n");

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

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

	/*
         * 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;

	if (status)
		goto err_detach_pm_domain;

	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);
	return status;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Dmitry Torokhov
175
38.38%
2
9.52%
Lee Jones
44
9.65%
2
9.52%
Jean Delvare
36
7.89%
3
14.29%
David Brownell
35
7.68%
2
9.52%
Laurent Pinchart
33
7.24%
1
4.76%
Mika Westerberg
32
7.02%
1
4.76%
Marc Pignat
19
4.17%
1
4.76%
Lv Zheng
18
3.95%
1
4.76%
Sylwester Nawrocki
17
3.73%
1
4.76%
Geert Uytterhoeven
13
2.85%
1
4.76%
Ulf Hansson
10
2.19%
1
4.76%
Adrian Bunk
9
1.97%
1
4.76%
Hans Verkuil
7
1.54%
1
4.76%
Kieran Bingham
4
0.88%
1
4.76%
Grygorii Strashko
3
0.66%
1
4.76%
Andy Shevchenko
1
0.22%
1
4.76%
Total
456
100.00%
21
100.00%



static int i2c_device_remove(struct device *dev)
{
	struct i2c_client	*client = i2c_verify_client(dev);
	struct i2c_driver	*driver;
	int status = 0;

	if (!client || !dev->driver)
		return 0;

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

	dev_pm_domain_detach(&client->dev, true);

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

	return status;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David Brownell
72
66.67%
2
25.00%
Dmitry Torokhov
18
16.67%
1
12.50%
Lv Zheng
9
8.33%
1
12.50%
Jean Delvare
4
3.70%
1
12.50%
Wolfram Sang
2
1.85%
1
12.50%
Adrian Bunk
2
1.85%
1
12.50%
Ulf Hansson
1
0.93%
1
12.50%
Total
108
100.00%
8
100.00%



static void i2c_device_shutdown(struct device *dev)
{
	struct i2c_client *client = i2c_verify_client(dev);
	struct i2c_driver *driver;

	if (!client || !dev->driver)
		return;
	driver = to_i2c_driver(dev->driver);
	if (driver->shutdown)
		driver->shutdown(client);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David Brownell
32
54.24%
1
20.00%
Jean Delvare
15
25.42%
1
20.00%
Adrian Bunk
7
11.86%
1
20.00%
Rafael J. Wysocki
3
5.08%
1
20.00%
Greg Kroah-Hartman
2
3.39%
1
20.00%
Total
59
100.00%
5
100.00%



static void i2c_client_dev_release(struct device *dev)
{
	kfree(to_i2c_client(dev));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David Brownell
19
100.00%
1
100.00%
Total
19
100.00%
1
100.00%


static ssize_t

show_name(struct device *dev, struct device_attribute *attr, char *buf)
{
	return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
		       to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
David Brownell
30
61.22%
1
50.00%
Jean Delvare
19
38.78%
1
50.00%
Total
49
100.00%
2
100.00%

static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);


static ssize_t

show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct i2c_client *client = to_i2c_client(dev);
	int len;

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

	return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
David Brownell
32
45.71%
1
33.33%
Rui Zhang
26
37.14%
1
33.33%
Jean Delvare
12
17.14%
1
33.33%
Total
70
100.00%
3
100.00%

static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);


static struct attribute *i2c_dev_attrs[] = {
	&dev_attr_name.attr,
	/* modalias helps coldplug:  modprobe $(cat .../modalias) */
	&dev_attr_modalias.attr,
	NULL
};

ATTRIBUTE_GROUPS(i2c_dev);


struct bus_type i2c_bus_type = {
	.name		= "i2c",
	.match		= i2c_device_match,
	.probe		= i2c_device_probe,
	.remove		= i2c_device_remove,
	.shutdown	= i2c_device_shutdown,
};

EXPORT_SYMBOL_GPL(i2c_bus_type);


static struct device_type i2c_client_type = {
	.groups		= i2c_dev_groups,
	.uevent		= i2c_device_uevent,
	.release	= i2c_client_dev_release,
};


/**
 * 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)
{
	return (dev->type == &i2c_client_type)
			? to_i2c_client(dev)
			: NULL;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
David Brownell
27
93.10%
1
50.00%
Jean Delvare
2
6.90%
1
50.00%
Total
29
100.00%
2
100.00%


EXPORT_SYMBOL(i2c_verify_client);


/* 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Wolfram Sang
48
100.00%
1
100.00%
Total
48
100.00%
1
100.00%

/* This is a permissive address validity check, I2C address map constraints
 * are purposely not enforced, except for the general call address. */


static int i2c_check_addr_validity(unsigned addr, unsigned short flags)
{
	if (flags & I2C_CLIENT_TEN) {
		/* 10-bit address, all values are valid */
		if (addr > 0x3ff)
			return -EINVAL;
	} else {
		/* 7-bit address, reject the general call address */
		if (addr == 0x00 || addr > 0x7f)
			return -EINVAL;
	}
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
46
86.79%
1
33.33%
Wolfram Sang
7
13.21%
2
66.67%
Total
53
100.00%
3
100.00%

/* 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. */


static int i2c_check_7bit_addr_validity_strict(unsigned short addr)
{
	/*
         * 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
27
96.43%
1
50.00%
Wolfram Sang
1
3.57%
1
50.00%
Total
28
100.00%
2
100.00%



static int __i2c_check_addr_busy(struct device *dev, void *addrp)
{
	struct i2c_client	*client = i2c_verify_client(dev);
	int			addr = *(int *)addrp;

	if (client && i2c_encode_flags_to_addr(client) == addr)
		return -EBUSY;
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
50
94.34%
1
50.00%
Wolfram Sang
3
5.66%
1
50.00%
Total
53
100.00%
2
100.00%

/* walk up mux tree */


static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
{
	struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
	int result;

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

	if (!result && parent)
		result = i2c_check_mux_parents(parent, addr);

	return result;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Michael Lawnick
50
81.97%
1
50.00%
Jean Delvare
11
18.03%
1
50.00%
Total
61
100.00%
2
100.00%

/* 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Michael Lawnick
51
100.00%
1
100.00%
Total
51
100.00%
1
100.00%



static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
{
	struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
	int result = 0;

	if (parent)
		result = i2c_check_mux_parents(parent, addr);

	if (!result)
		result = device_for_each_child(&adapter->dev, &addr,
						i2c_check_mux_children);

	return result;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
37
56.92%
2
66.67%
Michael Lawnick
28
43.08%
1
33.33%
Total
65
100.00%
3
100.00%

/**
 * i2c_adapter_lock_bus - Get exclusive access to an I2C bus segment
 * @adapter: Target I2C bus segment
 * @flags: I2C_LOCK_ROOT_ADAPTER locks the root i2c adapter, I2C_LOCK_SEGMENT
 *      locks only this branch in the adapter tree
 */


static void i2c_adapter_lock_bus(struct i2c_adapter *adapter,
				 unsigned int flags)
{
	rt_mutex_lock(&adapter->bus_lock);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
17
73.91%
1
50.00%
Peter Rosin
6
26.09%
1
50.00%
Total
23
100.00%
2
100.00%

/**
 * i2c_adapter_trylock_bus - Try to get exclusive access to an I2C bus segment
 * @adapter: Target I2C bus segment
 * @flags: I2C_LOCK_ROOT_ADAPTER trylocks the root i2c adapter, I2C_LOCK_SEGMENT
 *      trylocks only this branch in the adapter tree
 */


static int i2c_adapter_trylock_bus(struct i2c_adapter *adapter,
				   unsigned int flags)
{
	return rt_mutex_trylock(&adapter->bus_lock);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
19
79.17%
1
50.00%
Peter Rosin
5
20.83%
1
50.00%
Total
24
100.00%
2
100.00%

/**
 * i2c_adapter_unlock_bus - Release exclusive access to an I2C bus segment
 * @adapter: Target I2C bus segment
 * @flags: I2C_LOCK_ROOT_ADAPTER unlocks the root i2c adapter, I2C_LOCK_SEGMENT
 *      unlocks only this branch in the adapter tree
 */


static void i2c_adapter_unlock_bus(struct i2c_adapter *adapter,
				   unsigned int flags)
{
	rt_mutex_unlock(&adapter->bus_lock);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
17
73.91%
1
50.00%
Peter Rosin
6
26.09%
1
50.00%
Total
23
100.00%
2
100.00%



static void i2c_dev_set_name(struct i2c_adapter *adap,
			     struct i2c_client *client)
{
	struct acpi_device *adev = ACPI_COMPANION(&client->dev);

	if (adev) {
		dev_set_name(&client->dev, "i2c-%s", acpi_dev_name(adev));
		return;
	}

	dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
		     i2c_encode_flags_to_addr(client));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jarkko Nikula
68
95.77%
1
50.00%
Wolfram Sang
3
4.23%
1
50.00%
Total
71
100.00%
2
100.00%

/**
 * i2c_new_device - instantiate an i2c device
 * @adap: the adapter managing the device
 * @info: describes one I2C device; bus_num is ignored
 * Context: can sleep
 *
 * Create an i2c device. Binding is handled through driver model
 * probe()/remove() methods.  A driver may be bound to this device when we
 * return from this function, or any later moment (e.g. maybe hotplugging will
 * load the driver module).  This call is not appropriate for use by mainboard
 * initialization logic, which usually runs during an arch_initcall() long
 * before any i2c_adapter could exist.
 *
 * This returns the new i2c client, which may be saved for later use with
 * i2c_unregister_device(); or NULL to indicate an error.
 */

struct i2c_client *

i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
{
	struct i2c_client	*client;
	int			status;

	client = kzalloc(sizeof *client, GFP_KERNEL);
	if (!client)
		return NULL;

	client->adapter = adap;

	client->dev.platform_data = info->platform_data;

	if (info->archdata)
		client->dev.archdata = *info->archdata;

	client->flags = info->flags;
	client->addr = info->addr;
	client->irq = info->irq;

	strlcpy(client->name, info->type, sizeof(client->name));

	status = i2c_check_addr_validity(client->addr, client->flags);
	if (status) {
		dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
			client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
		goto out_err_silent;
	}

	/* Check for address business */
	status = i2c_check_addr_busy(adap, i2c_encode_flags_to_addr(client));
	if (status)
		goto out_err;

	client->dev.parent = &client->adapter->dev;
	client->dev.bus = &i2c_bus_type;
	client->dev.type = &i2c_client_type;
	client->dev.of_node = info->of_node;
	client->dev.fwnode = info->fwnode;

	i2c_dev_set_name(adap, client);

	if (info->properties) {
		status = device_add_properties(&client->dev, info->properties);
		if (status) {
			dev_err(&adap->dev,
				"Failed to add properties to client %s: %d\n",
				client->name, status);
			goto out_err;
		}
	}

	status = device_register(&client->dev);
	if (status)
		goto out_free_props;

	dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
		client->name, dev_name(&client->dev));

	return client;

out_free_props:
	if (info->properties)
		device_remove_properties(&client->dev);
out_err:
	dev_err(&adap->dev,
		"Failed to register i2c client %s at 0x%02x (%d)\n",
		client->name, client->addr, status);
out_err_silent:
	kfree(client);
	return NULL;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
150
39.37%
4
26.67%
David Brownell
118
30.97%
1
6.67%
Dmitry Torokhov
64
16.80%
1
6.67%
Anton Vorontsov
17
4.46%
1
6.67%
Wolfram Sang
10
2.62%
3
20.00%
Grant C. Likely
10
2.62%
1
6.67%
Mika Westerberg
6
1.57%
1
6.67%
Rafael J. Wysocki
4
1.05%
1
6.67%
Andy Shevchenko
1
0.26%
1
6.67%
Jarkko Nikula
1
0.26%
1
6.67%
Total
381
100.00%
15
100.00%


EXPORT_SYMBOL_GPL(i2c_new_device);


/**
 * i2c_unregister_device - reverse effect of i2c_new_device()
 * @client: value returned from i2c_new_device()
 * Context: can sleep
 */


void i2c_unregister_device(struct i2c_client *client)
{
	if (client->dev.of_node)
		of_node_clear_flag(client->dev.of_node, OF_POPULATED);
	if (ACPI_COMPANION(&client->dev))
		acpi_device_clear_enumerated(ACPI_COMPANION(&client->dev));
	device_unregister(&client->dev);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Octavian Purdila
21
36.21%
1
33.33%
Pantelis Antoniou
19
32.76%
1
33.33%
David Brownell
18
31.03%
1
33.33%
Total
58
100.00%
3
100.00%


EXPORT_SYMBOL_GPL(i2c_unregister_device);



static const struct i2c_device_id dummy_id[] = {
	{ "dummy", 0 },
	{ },
};



static int dummy_probe(struct i2c_client *client,
		       const struct i2c_device_id *id)
{
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
20
100.00%
1
100.00%
Total
20
100.00%
1
100.00%



static int dummy_remove(struct i2c_client *client)
{
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David Brownell
13
92.86%
1
50.00%
Jean Delvare
1
7.14%
1
50.00%
Total
14
100.00%
2
100.00%


static struct i2c_driver dummy_driver = {
	.driver.name	= "dummy",
	.probe		= dummy_probe,
	.remove		= dummy_remove,
	.id_table	= dummy_id,
};

/**
 * i2c_new_dummy - return a new i2c device bound to a dummy driver
 * @adapter: the adapter managing the device
 * @address: seven bit address to be used
 * Context: can sleep
 *
 * This returns an I2C client bound to the "dummy" driver, intended for use
 * with devices that consume multiple addresses.  Examples of such chips
 * include various EEPROMS (like 24c04 and 24c08 models).
 *
 * These dummy devices have two main uses.  First, most I2C and SMBus calls
 * except i2c_transfer() need a client handle; the dummy will be that handle.
 * And second, this prevents the specified address from being bound to a
 * different driver.
 *
 * This returns the new i2c client, which should be saved for later use with
 * i2c_unregister_device(); or NULL to indicate an error.
 */


struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
{
	struct i2c_board_info info = {
		I2C_BOARD_INFO("dummy", address),
        };

	return i2c_new_device(adapter, &info);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
David Brownell
33
89.19%
1
50.00%
Jean Delvare
4
10.81%
1
50.00%
Total
37
100.00%
2
100.00%


EXPORT_SYMBOL_GPL(i2c_new_dummy);

/**
 * i2c_new_secondary_device - Helper to get the instantiated secondary address
 * and create the associated device
 * @client: Handle to the primary client
 * @name: Handle to specify which secondary address to get
 * @default_addr: Used as a fallback if no secondary address was specified
 * Context: can sleep
 *
 * I2C clients can be composed of multiple I2C slaves bound together in a single
 * component. The I2C client driver then binds to the master I2C slave and needs
 * to create I2C dummy clients to communicate with all the other slaves.
 *
 * This function creates and returns an I2C dummy client whose I2C address is
 * retrieved from the platform firmware based on the given slave name. If no
 * address is specified by the firmware default_addr is used.
 *
 * On DT-based platforms the address is retrieved from the "reg" property entry
 * cell whose "reg-names" value matches the slave name.
 *
 * This returns the new i2c client, which should be saved for later use with
 * i2c_unregister_device(); or NULL to indicate an error.
 */


struct i2c_client *i2c_new_secondary_device(struct i2c_client *client,
						const char *name,
						u16 default_addr)
{
	struct device_node *np = client->dev.of_node;
	u32 addr = default_addr;
	int i;

	if (np) {
		i = of_property_match_string(np, "reg-names", name);
		if (i >= 0)
			of_property_read_u32_index(np, "reg", i, &addr);
	}

	dev_dbg(&client->adapter->dev, "Address for %s : 0x%x\n", name, addr);
	return i2c_new_dummy(client->adapter, addr);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean-Michel Hautbois
100
100.00%
1
100.00%
Total
100
100.00%
1
100.00%


EXPORT_SYMBOL_GPL(i2c_new_secondary_device);

/* ------------------------------------------------------------------------- */

/* I2C bus adapters -- one roots each I2C or SMBUS segment */



static void i2c_adapter_dev_release(struct device *dev)
{
	struct i2c_adapter *adap = to_i2c_adapter(dev);
	complete(&adap->dev_released);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Greg Kroah-Hartman
27
93.10%
1
33.33%
David Brownell
1
3.45%
1
33.33%
Adrian Bunk
1
3.45%
1
33.33%
Total
29
100.00%
3
100.00%



unsigned int i2c_adapter_depth(struct i2c_adapter *adapter)
{
	unsigned int depth = 0;

	while ((adapter = i2c_parent_is_i2c_adapter(adapter)))
		depth++;

	WARN_ONCE(depth >= MAX_LOCKDEP_SUBCLASSES,
		  "adapter depth exceeds lockdep subclass limit\n");

	return depth;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
34
79.07%
1
50.00%
Bartosz Golaszewski
9
20.93%
1
50.00%
Total
43
100.00%
2
100.00%


EXPORT_SYMBOL_GPL(i2c_adapter_depth);

/*
 * Let users instantiate I2C devices through sysfs. This can be used when
 * platform initialization code doesn't contain the proper data for
 * whatever reason. Also useful for drivers that do device detection and
 * detection fails, either because the device uses an unexpected address,
 * or this is a compatible device with different ID register values.
 *
 * Parameter checking may look overzealous, but we really don't want
 * the user to provide incorrect parameters.
 */

static ssize_t

i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
		     const char *buf, size_t count)
{
	struct i2c_adapter *adap = to_i2c_adapter(dev);
	struct i2c_board_info info;
	struct i2c_client *client;
	char *blank, end;
	int res;

	memset(&info, 0, sizeof(struct i2c_board_info));

	blank = strchr(buf, ' ');
	if (!blank) {
		dev_err(dev, "%s: Missing parameters\n", "new_device");
		return -EINVAL;
	}
	if (blank - buf > I2C_NAME_SIZE - 1) {
		dev_err(dev, "%s: Invalid device name\n", "new_device");
		return -EINVAL;
	}
	memcpy(info.type, buf, blank - buf);

	/* Parse remaining parameters, reject extra parameters */
	res = sscanf(++blank, "%hi%c", &info.addr, &end);
	if (res < 1) {
		dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
		return -EINVAL;
	}
	if (res > 1  && end != '\n') {
		dev_err(dev, "%s: Extra parameters\n", "new_device");
		return -EINVAL;
	}

	if ((info.addr & I2C_ADDR_OFFSET_TEN_BIT) == I2C_ADDR_OFFSET_TEN_BIT) {
		info.addr &= ~I2C_ADDR_OFFSET_TEN_BIT;
		info.flags |= I2C_CLIENT_TEN;
	}

	if (info.addr & I2C_ADDR_OFFSET_SLAVE) {
		info.addr &= ~I2C_ADDR_OFFSET_SLAVE;
		info.flags |= I2C_CLIENT_SLAVE;
	}

	client = i2c_new_device(adap, &info);
	if (!client)
		return -EINVAL;

	/* Keep track of the added device */
	mutex_lock(&adap->userspace_clients_lock);
	list_add_tail(&client->detected, &adap->userspace_clients);
	mutex_unlock(&adap->userspace_clients_lock);
	dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
		 info.type, info.addr);

	return count;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
267
84.23%
4
80.00%
Wolfram Sang
50
15.77%
1
20.00%
Total
317
100.00%
5
100.00%

static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);

/*
 * And of course let the users delete the devices they instantiated, if
 * they got it wrong. This interface can only be used to delete devices
 * instantiated by i2c_sysfs_new_device above. This guarantees that we
 * don't delete devices to which some kernel code still has references.
 *
 * Parameter checking may look overzealous, but we really don't want
 * the user to delete the wrong device.
 */

static ssize_t

i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
			const char *buf, size_t count)
{
	struct i2c_adapter *adap = to_i2c_adapter(dev);
	struct i2c_client *client, *next;
	unsigned short addr;
	char end;
	int res;

	/* Parse parameters, reject extra parameters */
	res = sscanf(buf, "%hi%c", &addr, &end);
	if (res < 1) {
		dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
		return -EINVAL;
	}
	if (res > 1  && end != '\n') {
		dev_err(dev, "%s: Extra parameters\n", "delete_device");
		return -EINVAL;
	}

	/* Make sure the device was added through sysfs */
	res = -ENOENT;
	mutex_lock_nested(&adap->userspace_clients_lock,
			  i2c_adapter_depth(adap));
	list_for_each_entry_safe(client, next, &adap->userspace_clients,
				 detected) {
		if (i2c_encode_flags_to_addr(client) == addr) {
			dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
				 "delete_device", client->name, client->addr);

			list_del(&client->detected);
			i2c_unregister_device(client);
			res = count;
			break;
		}
	}
	mutex_unlock(&adap->userspace_clients_lock);

	if (res < 0)
		dev_err(dev, "%s: Can't find device in list\n",
			"delete_device");
	return res;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
214
98.62%
4
80.00%
Wolfram Sang
3
1.38%
1
20.00%
Total
217
100.00%
5
100.00%

static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device, S_IWUSR, NULL,
				   i2c_sysfs_delete_device);


static struct attribute *i2c_adapter_attrs[] = {
	&dev_attr_name.attr,
	&dev_attr_new_device.attr,
	&dev_attr_delete_device.attr,
	NULL
};

ATTRIBUTE_GROUPS(i2c_adapter);


struct device_type i2c_adapter_type = {
	.groups		= i2c_adapter_groups,
	.release	= i2c_adapter_dev_release,
};

EXPORT_SYMBOL_GPL(i2c_adapter_type);

/**
 * i2c_verify_adapter - return parameter as i2c_adapter 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_adapter.
 */


struct i2c_adapter *i2c_verify_adapter(struct device *dev)
{
	return (dev->type == &i2c_adapter_type)
			? to_i2c_adapter(dev)
			: NULL;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Stephen Warren
29
100.00%
1
100.00%
Total
29
100.00%
1
100.00%


EXPORT_SYMBOL(i2c_verify_adapter);

#ifdef CONFIG_I2C_COMPAT

static struct class_compat *i2c_adapter_compat_class;
#endif



static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
{
	struct i2c_devinfo	*devinfo;

	down_read(&__i2c_board_lock);
	list_for_each_entry(devinfo, &__i2c_board_list, list) {
		if (devinfo->busnum == adapter->nr
				&& !i2c_new_device(adapter,
						&devinfo->board_info))
			dev_err(&adapter->dev,
				"Can't create device at 0x%02x\n",
				devinfo->board_info.addr);
	}
	up_read(&__i2c_board_lock);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David Brownell
67
89.33%
1
33.33%
Zhenwen Xu
6
8.00%
1
33.33%
Rodolfo Giometti
2
2.67%
1
33.33%
Total
75
100.00%
3
100.00%

/* OF support code */

#if IS_ENABLED(CONFIG_OF)


static struct i2c_client *of_i2c_register_device(struct i2c_adapter *adap,
						 struct device_node *node)
{
	struct i2c_client *result;
	struct i2c_board_info info = {};
	struct dev_archdata dev_ad = {};
	const __be32 *addr_be;
	u32 addr;
	int len;

	dev_dbg(&adap->dev, "of_i2c: register %s\n", node->full_name);

	if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
		dev_err(&adap->dev, "of_i2c: modalias failure on %s\n",
			node->full_name);
		return ERR_PTR(-EINVAL);
	}

	addr_be = of_get_property(node, "reg", &len);
	if (!addr_be || (len < sizeof(*addr_be))) {
		dev_err(&adap->dev, "of_i2c: invalid reg on %s\n",
			node->full_name);
		return ERR_PTR(-EINVAL);
	}

	addr = be32_to_cpup(addr_be);
	if (addr & I2C_TEN_BIT_ADDRESS) {
		addr &= ~I2C_TEN_BIT_ADDRESS;
		info.flags |= I2C_CLIENT_TEN;
	}

	if (addr & I2C_OWN_SLAVE_ADDRESS) {
		addr &= ~I2C_OWN_SLAVE_ADDRESS;
		info.flags |= I2C_CLIENT_SLAVE;
	}

	if (i2c_check_addr_validity(addr, info.flags)) {
		dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s\n",
			addr, node->full_name);
		return ERR_PTR(-EINVAL);
	}

	info.addr = addr;
	info.of_node = of_node_get(node);
	info.archdata = &dev_ad;

	if (of_property_read_bool(node, "host-notify"))
		info.flags |= I2C_CLIENT_HOST_NOTIFY;

	if (of_get_property(node, "wakeup-source", NULL))
		info.flags |= I2C_CLIENT_WAKE;

	result = i2c_new_device(adap, &info);
	if (result == NULL) {
		dev_err(&adap->dev, "of_i2c: Failure registering %s\n",
			node->full_name);
		of_node_put(node);
		return ERR_PTR(-EINVAL);
	}
	return result;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Wolfram Sang
278
82.99%
3
60.00%
Pantelis Antoniou
42
12.54%
1
20.00%
Dmitry Torokhov
15
4.48%
1
20.00%
Total
335
100.00%
5
100.00%



static void of_i2c_register_devices(struct i2c_adapter *adap)
{
	struct device_node *bus, *node;
	struct i2c_client *client;

	/* Only register child devices if the adapter has a node pointer set */
	if (!adap->dev.of_node)
		return;

	dev_dbg(&adap->dev, "of_i2c: walking child nodes\n");

	bus = of_get_child_by_name(adap->dev.of_node, "i2c-bus");
	if (!bus)
		bus = of_node_get(adap->dev.of_node);

	for_each_available_child_of_node(bus, node) {
		if (of_node_test_and_set_flag(node, OF_POPULATED))
			continue;

		client = of_i2c_register_device(adap, node);
		if (IS_ERR(client)) {
			dev_warn(&adap->dev,
				 "Failed to create I2C device for %s\n",
				 node->full_name);
			of_node_clear_flag(node, OF_POPULATED);
		}
	}

	of_node_put(bus);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Pantelis Antoniou
60
44.12%
2
40.00%
Jon Hunter
38
27.94%
1
20.00%
Ralf Ramsauer
37
27.21%
1
20.00%
Wolfram Sang
1
0.74%
1
20.00%
Total
136
100.00%
5
100.00%



static int of_dev_node_match(struct device *dev, void *data)
{
	return dev->of_node == data;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Wolfram Sang
22
100.00%
1
100.00%
Total
22
100.00%
1
100.00%

/* must call put_device() when done with returned i2c_client device */


struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
{
	struct device *dev;
	struct i2c_client *client;

	dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
	if (!dev)
		return NULL;

	client = i2c_verify_client(dev);
	if (!client)
		put_device(dev);

	return client;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Wolfram Sang
44
68.75%
1
50.00%
Vladimir Zapolskiy
20
31.25%
1
50.00%
Total
64
100.00%
2
100.00%


EXPORT_SYMBOL(of_find_i2c_device_by_node);

/* must call put_device() when done with returned i2c_adapter device */


struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node)
{
	struct device *dev;
	struct i2c_adapter *adapter;

	dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
	if (!dev)
		return NULL;

	adapter = i2c_verify_adapter(dev);
	if (!adapter)
		put_device(dev);

	return adapter;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Wolfram Sang
44
68.75%
1
50.00%
Vladimir Zapolskiy
20
31.25%
1
50.00%
Total
64
100.00%
2
100.00%


EXPORT_SYMBOL(of_find_i2c_adapter_by_node);

/* must call i2c_put_adapter() when done with returned i2c_adapter device */


struct i2c_adapter *of_get_i2c_adapter_by_node(struct device_node *node)
{
	struct i2c_adapter *adapter;

	adapter = of_find_i2c_adapter_by_node(node);
	if (!adapter)
		return NULL;

	if (!try_module_get(adapter->owner)) {
		put_device(&adapter->dev);
		adapter = NULL;
	}

	return adapter;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Vladimir Zapolskiy
59
100.00%
1
100.00%
Total
59
100.00%
1
100.00%


EXPORT_SYMBOL(of_get_i2c_adapter_by_node);


static const struct of_device_id*

i2c_of_match_device_sysfs(const struct of_device_id *matches,
				  struct i2c_client *client)
{
	const char *name;

	for (; matches->compatible[0]; matches++) {
		/*
                 * Adding devices through the i2c sysfs interface provides us
                 * a string to match which may be compatible with the device
                 * tree compatible strings, however with no actual of_node the
                 * of_match_device() will not match
                 */
		if (sysfs_streq(client->name, matches->compatible))
			return matches;

		name = strchr(matches->compatible, ',');
		if (!name)
			name = matches->compatible;
		else
			name++;

		if (sysfs_streq(client->name, name))
			return matches;
	}

	return NULL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Lee Jones
100
100.00%
1
100.00%
Total
100
100.00%
1
100.00%


const struct of_device_id

*i2c_of_match_device(const struct of_device_id *matches,
		     struct i2c_client *client)
{
	const struct of_device_id *match;

	if (!(client && matches))
		return NULL;

	match = of_match_device(matches, &client->dev);
	if (match)
		return match;

	return i2c_of_match_device_sysfs(matches, client);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Lee Jones
64
100.00%
1
100.00%
Total
64
100.00%
1
100.00%


EXPORT_SYMBOL_GPL(i2c_of_match_device);
#else


static void of_i2c_register_devices(struct i2c_adapter *adap) { }
Contributors
Person
Tokens
Prop
Commits
CommitProp
Wolfram Sang
10
100.00%
1
100.00%
Total
10
100.00%
1
100.00%

#endif /* CONFIG_OF */



static int i2c_do_add_adapter(struct i2c_driver *driver,
			      struct i2c_adapter *adap)
{
	/* Detect supported devices on that bus, and instantiate them */
	i2c_detect(adap, driver);

	/* Let legacy drivers scan this bus for matching devices */
	if (driver->attach_adapter) {
		dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
			 driver->driver.name);
		dev_warn(&adap->dev,
			 "Please use another way to instantiate your i2c_client\n");
		/* We ignore the return code; if it fails, too bad */
		driver->attach_adapter(adap);
	}
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
69
98.57%
5
83.33%
Andy Shevchenko
1
1.43%
1
16.67%
Total
70
100.00%
6
100.00%



static int __process_new_adapter(struct device_driver *d, void *data)
{
	return i2c_do_add_adapter(to_i2c_driver(d), data);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
26
100.00%
1
100.00%
Total
26
100.00%
1
100.00%


static const struct i2c_lock_operations i2c_adapter_lock_ops = {
	.lock_bus =    i2c_adapter_lock_bus,
	.trylock_bus = i2c_adapter_trylock_bus,
	.unlock_bus =  i2c_adapter_unlock_bus,
};



static void i2c_host_notify_irq_teardown(struct i2c_adapter *adap)
{
	struct irq_domain *domain = adap->host_notify_domain;
	irq_hw_number_t hwirq;

	if (!domain)
		return;

	for (hwirq = 0 ; hwirq < I2C_ADDR_7BITS_COUNT ; hwirq++)
		irq_dispose_mapping(irq_find_mapping(domain, hwirq));

	irq_domain_remove(domain);
	adap->host_notify_domain = NULL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Benjamin Tissoires
63
100.00%
1
100.00%
Total
63
100.00%
1
100.00%



static int i2c_host_notify_irq_map(struct irq_domain *h,
					  unsigned int virq,
					  irq_hw_number_t hw_irq_num)
{
	irq_set_chip_and_handler(virq, &dummy_irq_chip, handle_simple_irq);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Benjamin Tissoires
31
100.00%
1
100.00%
Total
31
100.00%
1
100.00%


static const struct irq_domain_ops i2c_host_notify_irq_ops = {
	.map = i2c_host_notify_irq_map,
};



static int i2c_setup_host_notify_irq_domain(struct i2c_adapter *adap)
{
	struct irq_domain *domain;

	if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_HOST_NOTIFY))
		return 0;

	domain = irq_domain_create_linear(adap->dev.fwnode,
					  I2C_ADDR_7BITS_COUNT,
					  &i2c_host_notify_irq_ops, adap);
	if (!domain)
		return -ENOMEM;

	adap->host_notify_domain = domain;

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Benjamin Tissoires
65
100.00%
1
100.00%
Total
65
100.00%
1
100.00%

/**
 * i2c_handle_smbus_host_notify - Forward a Host Notify event to the correct
 * I2C client.
 * @adap: the adapter
 * @addr: the I2C address of the notifying device
 * Context: can't sleep
 *
 * Helper function to be called from an I2C bus driver's interrupt
 * handler. It will schedule the Host Notify IRQ.
 */


int i2c_handle_smbus_host_notify(struct i2c_adapter *adap, unsigned short addr)
{
	int irq;

	if (!adap)
		return -EINVAL;

	irq = irq_find_mapping(adap->host_notify_domain, addr);
	if (irq <= 0)
		return -ENXIO;

	generic_handle_irq(irq);

	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Benjamin Tissoires
55
100.00%
1
100.00%
Total
55
100.00%
1
100.00%


EXPORT_SYMBOL_GPL(i2c_handle_smbus_host_notify);



static int i2c_register_adapter(struct i2c_adapter *adap)
{
	int res = -EINVAL;

	/* Can't register until after driver model init */
	if (WARN_ON(!is_registered)) {
		res = -EAGAIN;
		goto out_list;
	}

	/* Sanity checks */
	if (WARN(!adap->name[0], "i2c adapter has no name"))
		goto out_list;

	if (!adap->algo) {
		pr_err("adapter '%s': no algo supplied!\n", adap->name);
		goto out_list;
	}

	if (!adap->lock_ops)
		adap->lock_ops = &i2c_adapter_lock_ops;

	rt_mutex_init(&adap->bus_lock);
	rt_mutex_init(&adap->mux_lock);
	mutex_init(&adap->userspace_clients_lock);
	INIT_LIST_HEAD(&adap->userspace_clients);

	/* Set default timeout to 1 second if not already set */
	if (adap->timeout == 0)
		adap->timeout = HZ;

	/* register soft irqs for Host Notify */
	res = i2c_setup_host_notify_irq_domain(adap);
	if (res) {
		pr_err("adapter '%s': can't create Host Notify IRQs (%d)\n",
		       adap->name, res);
		goto out_list;
	}

	dev_set_name(&adap->dev, "i2c-%d", adap->nr);
	adap->dev.bus = &i2c_bus_type;
	adap->dev.type = &i2c_adapter_type;
	res = device_register(&adap->dev);
	if (res) {
		pr_err("adapter '%s': can't register device (%d)\n", adap->name, res);
		goto out_list;
	}

	dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);

	pm_runtime_no_callbacks(&adap->dev);
	pm_suspend_ignore_children(&adap->dev, true);
	pm_runtime_enable(&adap->dev);

#ifdef CONFIG_I2C_COMPAT
	res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
				       adap->dev.parent);
	if (res)
		dev_warn(&adap->dev,
			 "Failed to create compatibility class link\n");
#endif

	i2c_init_recovery(adap);

	/* create pre-declared device nodes */
	of_i2c_register_devices(adap);
	i2c_acpi_register_devices(adap);
	i2c_acpi_install_space_handler(adap);

	if (adap->nr < __i2c_first_dynamic_bus_num)
		i2c_scan_static_board_info(adap);

	/* Notify drivers */
	mutex_lock(&core_lock);
	bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
	mutex_unlock(&core_lock);

	return 0;

out_list:
	mutex_lock(&core_lock);
	idr_remove(&i2c_adapter_idr, adap->nr);
	mutex_unlock(&core_lock);
	return res;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
182
46.31%
15
33.33%
Wolfram Sang
40
10.18%
6
13.33%
David Brownell
28
7.12%
2
4.44%
Benjamin Tissoires
28
7.12%
1
2.22%
Greg Kroah-Hartman
24
6.11%
3
6.67%
Peter Rosin
22
5.60%
3
6.67%
Linus Torvalds (pre-git)
16
4.07%
2
4.44%
Linus Walleij
10
2.54%
1
2.22%
Faik Uygur
9
2.29%
1
2.22%
Charles Keepax
8
2.04%
1
2.22%
Gerd Knorr
6
1.53%
1
2.22%
Viresh Kumar
4
1.02%
1
2.22%
Mika Westerberg
4
1.02%
1
2.22%
Lan Tianyu
4
1.02%
1
2.22%
Jarkko Nikula
2
0.51%
1
2.22%
Kay Sievers
2
0.51%
1
2.22%
Mika Kuoppala
1
0.25%
1
2.22%
Christoph Hellwig
1
0.25%
1
2.22%
Sudip Mukherjee
1
0.25%
1
2.22%
Arjan van de Ven
1
0.25%
1
2.22%
Total
393
100.00%
45
100.00%

/**
 * __i2c_add_numbered_adapter - i2c_add_numbered_adapter where nr is never -1
 * @adap: the adapter to register (with adap->nr initialized)
 * Context: can sleep
 *
 * See i2c_add_numbered_adapter() for details.
 */


static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
{
	int id;

	mutex_lock(&core_lock);
	id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1, GFP_KERNEL);
	mutex_unlock(&core_lock);
	if (WARN(id < 0, "couldn't get idr"))
		return id == -ENOSPC ? -EBUSY : id;

	return i2c_register_adapter(adap);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David Brownell
42
55.26%
1
20.00%
Douglas Anderson
21
27.63%
1
20.00%
Tejun Heo
6
7.89%
1
20.00%
Wolfram Sang
5
6.58%
1
20.00%
Jean Delvare
2
2.63%
1
20.00%
Total
76
100.00%
5
100.00%

/**
 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
 * @adapter: the adapter to add
 * Context: can sleep
 *
 * This routine is used to declare an I2C adapter when its bus number
 * doesn't matter or when its bus number is specified by an dt alias.
 * Examples of bases when the bus number doesn't matter: I2C adapters
 * dynamically added by USB links or PCI plugin cards.
 *
 * When this returns zero, a new bus number was allocated and stored
 * in adap->nr, and the specified adapter became available for clients.
 * Otherwise, a negative errno value is returned.
 */


int i2c_add_adapter(struct i2c_adapter *adapter)
{
	struct device *dev = &adapter->dev;
	int id;

	if (dev->of_node) {
		id = of_alias_get_id(dev->of_node, "i2c");
		if (id >= 0) {
			adapter->nr = id;
			return __i2c_add_numbered_adapter(adapter);
		}
	}

	mutex_lock(&core_lock);
	id = idr_alloc(&i2c_adapter_idr, adapter,
		       __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
	mutex_unlock(&core_lock);
	if (WARN(id < 0, "couldn't get idr"))
		return id;

	adapter->nr = id;

	return i2c_register_adapter(adapter);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Douglas Anderson
60
51.72%
1
16.67%
David Brownell
37
31.90%
1
16.67%
Tejun Heo
7
6.03%
1
16.67%
Wolfram Sang
5
4.31%
1
16.67%
Grant C. Likely
5
4.31%
1
16.67%
Jean Delvare
2
1.72%
1
16.67%
Total
116
100.00%
6
100.00%


EXPORT_SYMBOL(i2c_add_adapter);

/**
 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
 * @adap: the adapter to register (with adap->nr initialized)
 * Context: can sleep
 *
 * This routine is used to declare an I2C adapter when its bus number
 * matters.  For example, use it for I2C adapters from system-on-chip CPUs,
 * or otherwise built in to the system's mainboard, and where i2c_board_info
 * is used to properly configure I2C devices.
 *
 * If the requested bus number is set to -1, then this function will behave
 * identically to i2c_add_adapter, and will dynamically assign a bus number.
 *
 * If no devices have pre-been declared for this bus, then be sure to
 * register the adapter before any dynamically allocated ones.  Otherwise
 * the required bus ID may not be available.
 *
 * When this returns zero, the specified adapter became available for
 * clients using the bus number provided in adap->nr.  Also, the table
 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
 * and the appropriate driver model device nodes are created.  Otherwise, a
 * negative errno value is returned.
 */


int i2c_add_numbered_adapter(struct i2c_adapter *adap)
{
	if (adap->nr == -1) /* -1 means dynamically assign bus id */
		return i2c_add_adapter(adap);

	return __i2c_add_numbered_adapter(adap);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Douglas Anderson
23
71.88%
1
33.33%
David Brownell
5
15.62%
1
33.33%
Tejun Heo
4
12.50%
1
33.33%
Total
32
100.00%
3
100.00%


EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);



static void i2c_do_del_adapter(struct i2c_driver *driver,
			      struct i2c_adapter *adapter)
{
	struct i2c_client *client, *_n;

	/* Remove the devices we created ourselves as the result of hardware
         * probing (using a driver's detect method) */
	list_for_each_entry_safe(client, _n, &driver->clients, detected) {
		if (client->adapter == adapter) {
			dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
				client->name, client->addr);
			list_del(&client->detected);
			i2c_unregister_device(client);
		}
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
77
98.72%
4
80.00%
Lars-Peter Clausen
1
1.28%
1
20.00%
Total
78
100.00%
5
100.00%



static int __unregister_client(struct device *dev, void *dummy)
{
	struct i2c_client *client = i2c_verify_client(dev);
	if (client && strcmp(client->name, "dummy"))
		i2c_unregister_device(client);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
46
100.00%
2
100.00%
Total
46
100.00%
2
100.00%



static int __unregister_dummy(struct device *dev, void *dummy)
{
	struct i2c_client *client = i2c_verify_client(dev);
	if (client)
		i2c_unregister_device(client);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
37
100.00%
2
100.00%
Total
37
100.00%
2
100.00%



static int __process_removed_adapter(struct device_driver *d, void *data)
{
	i2c_do_del_adapter(to_i2c_driver(d), data);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
25
89.29%
1
50.00%
Lars-Peter Clausen
3
10.71%
1
50.00%
Total
28
100.00%
2
100.00%

/**
 * i2c_del_adapter - unregister I2C adapter
 * @adap: the adapter being unregistered
 * Context: can sleep
 *
 * This unregisters an I2C adapter which was previously registered
 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
 */


void i2c_del_adapter(struct i2c_adapter *adap)
{
	struct i2c_adapter *found;
	struct i2c_client *client, *next;

	/* First make sure that this adapter was ever added */
	mutex_lock(&core_lock);
	found = idr_find(&i2c_adapter_idr, adap->nr);
	mutex_unlock(&core_lock);
	if (found != adap) {
		pr_debug("attempting to delete unregistered adapter [%s]\n", adap->name);
		return;
	}

	i2c_acpi_remove_space_handler(adap);
	/* Tell drivers about this removal */
	mutex_lock(&core_lock);
	bus_for_each_drv(&i2c_bus_type, NULL, adap,
			       __process_removed_adapter);
	mutex_unlock(&core_lock);

	/* Remove devices instantiated from sysfs */
	mutex_lock_nested(&adap->userspace_clients_lock,
			  i2c_adapter_depth(adap));
	list_for_each_entry_safe(client, next, &adap->userspace_clients,
				 detected) {
		dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
			client->addr);
		list_del(&client->detected);
		i2c_unregister_device(client);
	}
	mutex_unlock(&adap->userspace_clients_lock);

	/* Detach any active clients. This can't fail, thus we do not
         * check the returned value. This is a two-pass process, because
         * we can't remove the dummy devices during the first pass: they
         * could have been instantiated by real devices wishing to clean
         * them up properly, so we give them a chance to do that first. */
	device_for_each_child(&adap->dev, NULL, __unregister_client);
	device_for_each_child(&adap->dev, NULL, __unregister_dummy);

#ifdef CONFIG_I2C_COMPAT
	class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
				 adap->dev.parent);
#endif

	/* device name is gone after device_unregister */
	dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);

	pm_runtime_disable(&adap->dev);

	i2c_host_notify_irq_teardown(adap);

	/* wait until all references to the device are gone
         *
         * FIXME: This is old code and should ideally be replaced by an
         * alternative which results in decoupling the lifetime of the struct
         * device from the i2c_adapter, like spi or netdev do. Any solution
         * should be thoroughly tested with DEBUG_KOBJECT_RELEASE enabled!
         */
	init_completion(&adap->dev_released);
	device_unregister(&adap->dev);
	wait_for_completion(&adap->dev_released);

	/* free bus id */
	mutex_lock(&core_lock);
	idr_remove(&i2c_adapter_idr, adap->nr);
	mutex_unlock(&core_lock);

	/* Clear the device structure in case this adapter is ever going to be
           added again */
	memset(&adap->dev, 0, sizeof(adap->dev));
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
205
68.11%
15
42.86%
Greg Kroah-Hartman
24
7.97%
2
5.71%
Thadeu Lima de Souza Cascardo
15
4.98%
1
2.86%
Linus Torvalds (pre-git)
11
3.65%
2
5.71%
Faik Uygur
10
3.32%
1
2.86%
Wolfram Sang
9
2.99%
2
5.71%
Benjamin Tissoires
5
1.66%
1
2.86%
Gerd Knorr
5
1.66%
1
2.86%
Lan Tianyu
4
1.33%
1
2.86%
David Brownell
3
1.00%
2
5.71%
Christoph Hellwig
3
1.00%
1
2.86%
Lars-Peter Clausen
2
0.66%
1
2.86%
Matthias Kaehlcke
1
0.33%
1
2.86%
Arjan van de Ven
1
0.33%
1
2.86%
Shailendra Verma
1
0.33%
1
2.86%
Jarkko Nikula
1
0.33%
1
2.86%
Andreas Schultz
1
0.33%
1
2.86%
Total
301
100.00%
35
100.00%


EXPORT_SYMBOL(i2c_del_adapter);

/**
 * i2c_parse_fw_timings - get I2C related timing parameters from firmware
 * @dev: The device to scan for I2C timing properties
 * @t: the i2c_timings struct to be filled with values
 * @use_defaults: bool to use sane defaults derived from the I2C specification
 *                when properties are not found, otherwise use 0
 *
 * Scan the device for the generic I2C properties describing timing parameters
 * for the signal and fill the given struct with the results. If a property was
 * not found and use_defaults was true, then maximum timings are assumed which
 * are derived from the I2C specification. If use_defaults is not used, the
 * results will be 0, so drivers can apply their own defaults later. The latter
 * is mainly intended for avoiding regressions of existing drivers which want
 * to switch to this function. New drivers almost always should use the defaults.
 */



void i2c_parse_fw_timings(struct device *dev, struct i2c_timings *t, bool use_defaults)
{
	int ret;

	memset(t, 0, sizeof(*t));

	ret = device_property_read_u32(dev, "clock-frequency", &t->bus_freq_hz);
	if (ret && use_defaults)
		t->bus_freq_hz = 100000;

	ret = device_property_read_u32(dev, "i2c-scl-rising-time-ns", &t->scl_rise_ns);
	if (ret && use_defaults) {
		if (t->bus_freq_hz <= 100000)
			t->scl_rise_ns = 1000;
		else if (t->bus_freq_hz <= 400000)
			t->scl_rise_ns = 300;
		else
			t->scl_rise_ns = 120;
	}

	ret = device_property_read_u32(dev, "i2c-scl-falling-time-ns", &t->scl_fall_ns);
	if (ret && use_defaults) {
		if (t->bus_freq_hz <= 400000)
			t->scl_fall_ns = 300;
		else
			t->scl_fall_ns = 120;
	}

	device_property_read_u32(dev, "i2c-scl-internal-delay-ns", &t->scl_int_delay_ns);

	ret = device_property_read_u32(dev, "i2c-sda-falling-time-ns", &t->sda_fall_ns);
	if (ret && use_defaults)
		t->sda_fall_ns = t->scl_fall_ns;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Wolfram Sang
201
100.00%
1
100.00%
Total
201
100.00%
1
100.00%


EXPORT_SYMBOL_GPL(i2c_parse_fw_timings);

/* ------------------------------------------------------------------------- */



int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
{
	int res;

	mutex_lock(&core_lock);
	res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
	mutex_unlock(&core_lock);

	return res;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
55
100.00%
1
100.00%
Total
55
100.00%
1
100.00%


EXPORT_SYMBOL_GPL(i2c_for_each_dev);



static int __process_new_driver(struct device *dev, void *data)
{
	if (dev->type != &i2c_adapter_type)
		return 0;
	return i2c_do_add_adapter(data, to_i2c_adapter(dev));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
22
57.89%
2
66.67%
Dave Young
16
42.11%
1
33.33%
Total
38
100.00%
3
100.00%

/*
 * An i2c_driver is used with one or more i2c_client (device) nodes to access
 * i2c slave chips, on a bus instance associated with some i2c_adapter.
 */



int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
{
	int res;

	/* Can't register until after driver model init */
	if (WARN_ON(!is_registered))
		return -EAGAIN;

	/* add the driver to the list of i2c drivers in the driver core */
	driver->driver.owner = owner;
	driver->driver.bus = &i2c_bus_type;
	INIT_LIST_HEAD(&driver->clients);

	/* When registration returns, the driver core
         * will have called probe() for all matching-but-unbound devices.
         */
	res = driver_register(&driver->driver);
	if (res)
		return res;

	pr_debug("driver [%s] registered\n", driver->driver.name);

	/* Walk the adapters that are already present */
	i2c_for_each_dev(driver, __process_new_driver);

	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Greg Kroah-Hartman
39
40.21%
3
15.00%
Linus Torvalds (pre-git)
14
14.43%
2
10.00%
David Brownell
12
12.37%
1
5.00%
Jean Delvare
11
11.34%
7
35.00%
Vladimir Zapolskiy
8
8.25%
1
5.00%
Gerd Knorr
7
7.22%
1
5.00%
Laurent Riffard
2
2.06%
1
5.00%
Wolfram Sang
1
1.03%
1
5.00%
Sudip Mukherjee
1
1.03%
1
5.00%
Christoph Hellwig
1
1.03%
1
5.00%
Dave Young
1
1.03%
1
5.00%
Total
97
100.00%
20
100.00%


EXPORT_SYMBOL(i2c_register_driver);



static int __process_removed_driver(struct device *dev, void *data)
{
	if (dev->type == &i2c_adapter_type)
		i2c_do_del_adapter(data, to_i2c_adapter(dev));
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
18
48.65%
3
50.00%
Dave Young
9
24.32%
1
16.67%
Linus Torvalds (pre-git)
6
16.22%
1
16.67%
Lars-Peter Clausen
4
10.81%
1
16.67%
Total
37
100.00%
6
100.00%

/**
 * i2c_del_driver - unregister I2C driver
 * @driver: the driver being unregistered
 * Context: can sleep
 */


void i2c_del_driver(struct i2c_driver *driver)
{
	i2c_for_each_dev(driver, __process_removed_driver);

	driver_unregister(&driver->driver);
	pr_debug("driver [%s] unregistered\n", driver->driver.name);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Dave Young
11
30.56%
1
11.11%
Linus Torvalds (pre-git)
8
22.22%
1
11.11%
Gerd Knorr
8
22.22%
1
11.11%
Jean Delvare
5
13.89%
3
33.33%
Laurent Riffard
2
5.56%
1
11.11%
Wolfram Sang
1
2.78%
1
11.11%
Greg Kroah-Hartman
1
2.78%
1
11.11%
Total
36
100.00%
9
100.00%


EXPORT_SYMBOL(i2c_del_driver);

/* ------------------------------------------------------------------------- */

/**
 * i2c_use_client - increments the reference count of the i2c client structure
 * @client: the client being referenced
 *
 * Each live reference to a client should be refcounted. The driver model does
 * that automatically as part of driver binding, so that most drivers don't
 * need to do this explicitly: they hold a reference until they're unbound
 * from the device.
 *
 * A pointer to the client with the incremented reference counter is returned.
 */


struct i2c_client *i2c_use_client(struct i2c_client *client)
{
	if (client && get_device(&client->dev))
		return client;
	return NULL;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
11
36.67%
2
33.33%
Jean Delvare
8
26.67%
2
33.33%
David Brownell
8
26.67%
1
16.67%
Christoph Hellwig
3
10.00%
1
16.67%
Total
30
100.00%
6
100.00%


EXPORT_SYMBOL(i2c_use_client);

/**
 * i2c_release_client - release a use of the i2c client structure
 * @client: the client being no longer referenced
 *
 * Must be called when a user of a client is finished with it.
 */


void i2c_release_client(struct i2c_client *client)
{
	if (client)
		put_device(&client->dev);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
12
54.55%
2
33.33%
Jean Delvare
6
27.27%
3
50.00%
David Brownell
4
18.18%
1
16.67%
Total
22
100.00%
6
100.00%


EXPORT_SYMBOL(i2c_release_client);


struct i2c_cmd_arg {
	
unsigned	cmd;
	
void		*arg;
};



static int i2c_cmd(struct device *dev, void *_arg)
{
	struct i2c_client	*client = i2c_verify_client(dev);
	struct i2c_cmd_arg	*arg = _arg;
	struct i2c_driver	*driver;

	if (!client || !client->dev.driver)
		return 0;

	driver = to_i2c_driver(client->dev.driver);
	if (driver->command)
		driver->command(client, arg->cmd, arg->arg);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Gerd Knorr
38
43.68%
1
33.33%
Lars-Peter Clausen
25
28.74%
1
33.33%
David Brownell
24
27.59%
1
33.33%
Total
87
100.00%
3
100.00%



void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
{
	struct i2c_cmd_arg	cmd_arg;

	cmd_arg.cmd = cmd;
	cmd_arg.arg = arg;
	device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
David Brownell
38
80.85%
1
33.33%
Gerd Knorr
8
17.02%
1
33.33%
Laurent Riffard
1
2.13%
1
33.33%
Total
47
100.00%
3
100.00%


EXPORT_SYMBOL(i2c_clients_command);

#if IS_ENABLED(CONFIG_OF_DYNAMIC)


static int of_i2c_notify(struct notifier_block *nb, unsigned long action,
			 void *arg)
{
	struct of_reconfig_data *rd = arg;
	struct i2c_adapter *adap;
	struct i2c_client *client;

	switch (of_reconfig_get_state_change(action, rd)) {
	case OF_RECONFIG_CHANGE_ADD:
		adap = of_find_i2c_adapter_by_node(rd->dn->parent);
		if (adap == NULL)
			return NOTIFY_OK;	/* not for us */

		if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) {
			put_device(&adap->dev);
			return NOTIFY_OK;
		}

		client = of_i2c_register_device(adap, rd->dn);
		put_device(&adap->dev);

		if (IS_ERR(client)) {
			dev_err(&adap->dev, "failed to create client for '%s'\n",
				 rd->dn->full_name);
			of_node_clear_flag(rd->dn, OF_POPULATED);
			return notifier_from_errno(PTR_ERR(client));
		}
		break;
	case OF_RECONFIG_CHANGE_REMOVE:
		/* already depopulated? */
		if (!of_node_check_flag(rd->dn, OF_POPULATED))
			return NOTIFY_OK;

		/* find our device by node */
		client = of_find_i2c_device_by_node(rd->dn);
		if (client == NULL)
			return NOTIFY_OK;	/* no? not meant for us */

		/* unregister takes one ref away */
		i2c_unregister_device(client);

		/* and put the reference of the find */
		put_device(&client->dev);
		break;
	}

	return NOTIFY_OK;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Pantelis Antoniou
201
93.06%
2
50.00%
Ralf Ramsauer
9
4.17%
1
25.00%
Wolfram Sang
6
2.78%
1
25.00%
Total
216
100.00%
4
100.00%


static struct notifier_block i2c_of_notifier = {
	.notifier_call = of_i2c_notify,
};
#else
extern struct notifier_block i2c_of_notifier;
#endif /* CONFIG_OF_DYNAMIC */



static int __init i2c_init(void)
{
	int retval;

	retval = of_alias_get_highest_id("i2c");

	down_write(&__i2c_board_lock);
	if (retval >= __i2c_first_dynamic_bus_num)
		__i2c_first_dynamic_bus_num = retval + 1;
	up_write(&__i2c_board_lock);

	retval = bus_register(&i2c_bus_type);
	if (retval)
		return retval;

	is_registered = true;

#ifdef CONFIG_I2C_COMPAT
	i2c_adapter_compat_class = class_compat_register("i2c-adapter");
	if (!i2c_adapter_compat_class) {
		retval = -ENOMEM;
		goto bus_err;
	}
#endif
	retval = i2c_add_driver(&dummy_driver);
	if (retval)
		goto class_err;

	if (IS_ENABLED(CONFIG_OF_DYNAMIC))
		WARN_ON(of_reconfig_notifier_register(&i2c_of_notifier));
	if (IS_ENABLED(CONFIG_ACPI))
		WARN_ON(acpi_reconfig_notifier_register(&i2c_acpi_notifier));

	return 0;

class_err:
#ifdef CONFIG_I2C_COMPAT
	class_compat_unregister(i2c_adapter_compat_class);
bus_err:
#endif
	is_registered = false;
	bus_unregister(&i2c_bus_type);
	return retval;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
40
24.10%
1
11.11%
Wolfram Sang
39
23.49%
2
22.22%
David Brownell
27
16.27%
1
11.11%
Greg Kroah-Hartman
24
14.46%
2
22.22%
Pantelis Antoniou
16
9.64%
1
11.11%
Octavian Purdila
16
9.64%
1
11.11%
Linus Torvalds (pre-git)
4
2.41%
1
11.11%
Total
166
100.00%
9
100.00%



static void __exit i2c_exit(void)
{
	if (IS_ENABLED(CONFIG_ACPI))
		WARN_ON(acpi_reconfig_notifier_unregister(&i2c_acpi_notifier));
	if (IS_ENABLED(CONFIG_OF_DYNAMIC))
		WARN_ON(of_reconfig_notifier_unregister(&i2c_of_notifier));
	i2c_del_driver(&dummy_driver);
#ifdef CONFIG_I2C_COMPAT
	class_compat_unregister(i2c_adapter_compat_class);
#endif
	bus_unregister(&i2c_bus_type);
	tracepoint_synchronize_unregister();
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Pantelis Antoniou
16
24.24%
1
12.50%
Octavian Purdila
16
24.24%
1
12.50%
Greg Kroah-Hartman
14
21.21%
2
25.00%
Jean Delvare
10
15.15%
1
12.50%
David Brownell
6
9.09%
1
12.50%
David Howells
3
4.55%
1
12.50%
Linus Torvalds (pre-git)
1
1.52%
1
12.50%
Total
66
100.00%
8
100.00%

/* We must initialize early, because some subsystems register i2c drivers
 * in subsys_initcall() code, but are linked (and initialized) before i2c.
 */

postcore_initcall(i2c_init);

module_exit(i2c_exit);

/* ----------------------------------------------------
 * the functional interface to the i2c busses.
 * ----------------------------------------------------
 */

/* Check if val is exceeding the quirk IFF quirk is non 0 */

#define i2c_quirk_exceeded(val, quirk) ((quirk) && ((val) > (quirk)))



static int i2c_quirk_error(struct i2c_adapter *adap, struct i2c_msg *msg, char *err_msg)
{
	dev_err_ratelimited(&adap->dev, "adapter quirk: %s (addr 0x%04x, size %u, %s)\n",
			    err_msg, msg->addr, msg->len,
			    msg->flags & I2C_M_RD ? "read" : "write");
	return -EOPNOTSUPP;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Wolfram Sang
54
100.00%
1
100.00%
Total
54
100.00%
1
100.00%



static int i2c_check_for_quirks(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
{
	const struct i2c_adapter_quirks *q = adap->quirks;
	int max_num = q->max_num_msgs, i;
	bool do_len_check = true;

	if (q->flags & I2C_AQ_COMB) {
		max_num = 2;

		/* special checks for combined messages */
		if (num == 2) {
			if (q->flags & I2C_AQ_COMB_WRITE_FIRST && msgs[0].flags & I2C_M_RD)
				return i2c_quirk_error(adap, &msgs[0], "1st comb msg must be write");

			if (q->flags & I2C_AQ_COMB_READ_SECOND && !(msgs[1].flags & I2C_M_RD))
				return i2c_quirk_error(adap, &msgs[1], "2nd comb msg must be read");

			if (q->flags & I2C_AQ_COMB_SAME_ADDR && msgs[0].addr != msgs[1].addr)
				return i2c_quirk_error(adap, &msgs[0], "comb msg only to same addr");

			if (i2c_quirk_exceeded(msgs[0].len, q->max_comb_1st_msg_len))
				return i2c_quirk_error(adap, &msgs[0], "msg too long");

			if (i2c_quirk_exceeded(msgs[1].len, q->max_comb_2nd_msg_len))
				return i2c_quirk_error(adap, &msgs[1], "msg too long");

			do_len_check = false;
		}
	}

	if (i2c_quirk_exceeded(num, max_num))
		return i2c_quirk_error(adap, &msgs[0], "too many messages");

	for (i = 0; i < num; i++) {
		u16 len = msgs[i].len;

		if (msgs[i].flags & I2C_M_RD) {
			if (do_len_check && i2c_quirk_exceeded(len, q->max_read_len))
				return i2c_quirk_error(adap, &msgs[i], "msg too long");
		} else {
			if (do_len_check && i2c_quirk_exceeded(len, q->max_write_len))
				return i2c_quirk_error(adap, &msgs[i], "msg too long");
		}
	}

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Wolfram Sang
352
100.00%
1
100.00%
Total
352
100.00%
1
100.00%

/**
 * __i2c_transfer - unlocked flavor of i2c_transfer
 * @adap: Handle to I2C bus
 * @msgs: One or more messages to execute before STOP is issued to
 *      terminate the operation; each message begins with a START.
 * @num: Number of messages to be executed.
 *
 * Returns negative errno, else the number of messages executed.
 *
 * Adapter lock must be held when calling this function. No debug logging
 * takes place. adap->algo->master_xfer existence isn't checked.
 */


int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
{
	unsigned long orig_jiffies;
	int ret, try;

	if (adap->quirks && i2c_check_for_quirks(adap, msgs, num))
		return -EOPNOTSUPP;

	/* i2c_trace_msg gets enabled when tracepoint i2c_transfer gets
         * enabled.  This is an efficient way of keeping the for-loop from
         * being executed when not needed.
         */
	if (static_key_false(&i2c_trace_msg)) {
		int i;
		for (i = 0; i < num; i++)
			if (msgs[i].flags & I2C_M_RD)
				trace_i2c_read(adap, &msgs[i], i);
			else
				trace_i2c_write(adap, &msgs[i], i);
	}

	/* Retry automatically on arbitration loss */
	orig_jiffies = jiffies;
	for (ret = 0, try = 0; try <= adap->retries; try++) {
		ret = adap->algo->master_xfer(adap, msgs, num);
		if (ret != -EAGAIN)
			break;
		if (time_after(jiffies, orig_jiffies + adap->timeout))
			break;
	}

	if (static_key_false(&i2c_trace_msg)) {
		int i;
		for (i = 0; i < ret; i++)
			if (msgs[i].flags & I2C_M_RD)
				trace_i2c_reply(adap, &msgs[i], i);
		trace_i2c_result(adap, i, ret);
	}

	return ret;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
David Howells
124
52.54%
1
16.67%
Jean Delvare
68
28.81%
1
16.67%
Wolfram Sang
19
8.05%
1
16.67%
Linus Torvalds (pre-git)
18
7.63%
1
16.67%
Clifford Wolf
6
2.54%
1
16.67%
Mickey Stein
1
0.42%
1
16.67%
Total
236
100.00%
6
100.00%


EXPORT_SYMBOL(__i2c_transfer);

/**
 * i2c_transfer - execute a single or combined I2C message
 * @adap: Handle to I2C bus
 * @msgs: One or more messages to execute before STOP is issued to
 *      terminate the operation; each message begins with a START.
 * @num: Number of messages to be executed.
 *
 * Returns negative errno, else the number of messages executed.
 *
 * Note that there is no requirement that each message be sent to
 * the same slave address, although that is the most common model.
 */


int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
{
	int ret;

	/* REVISIT the fault reporting model here is weak:
         *
         *  - When we get an error after receiving N bytes from a slave,
         *    there is no way to report "N".
         *
         *  - When we get a NAK after transmitting N bytes to a slave,
         *    there is no way to report "N" ... or to let the master
         *    continue executing the rest of this combined message, if
         *    that's the appropriate response.
         *
         *  - When for example "num" is two and we successfully complete
         *    the first message but get an error part way through the
         *    second, it's unclear whether that should be reported as
         *    one (discarding status on the second message) or errno
         *    (discarding status on the first one).
         */

	if (adap->algo->master_xfer) {
#ifdef DEBUG
		for (ret = 0; ret < num; ret++) {
			dev_dbg(&adap->dev,
				"master_xfer[%d] %c, addr=0x%02x, len=%d%s\n",
				ret, (msgs[ret].flags & I2C_M_RD) ? 'R' : 'W',
				msgs[ret].addr, msgs[ret].len,
				(msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
		}
#endif

		if (in_atomic() || irqs_disabled()) {
			ret = i2c_trylock_bus(adap, I2C_LOCK_SEGMENT);
			if (!ret)
				/* I2C activity is ongoing. */
				return -EAGAIN;
		} else {
			i2c_lock_bus(adap, I2C_LOCK_SEGMENT);
		}

		ret = __i2c_transfer(adap, msgs, num);
		i2c_unlock_bus(adap, I2C_LOCK_SEGMENT);

		return ret;
	} else {
		dev_dbg(&adap->dev, "I2C level transfers not supported\n");
		return -EOPNOTSUPP;
	}
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
86
46.49%
3
23.08%
Linus Torvalds (pre-git)
47
25.41%
1
7.69%
Mike Rapoport
29
15.68%
1
7.69%
Peter Rosin
9
4.86%
2
15.38%
Greg Kroah-Hartman
9
4.86%
2
15.38%
David Brownell
2
1.08%
2
15.38%
Clifford Wolf
2
1.08%
1
7.69%
Andy Shevchenko
1
0.54%
1
7.69%
Total
185
100.00%
13
100.00%


EXPORT_SYMBOL(i2c_transfer);

/**
 * i2c_master_send - issue a single I2C message in master transmit mode
 * @client: Handle to slave device
 * @buf: Data that will be written to the slave
 * @count: How many bytes to write, must be less than 64k since msg.len is u16
 *
 * Returns negative errno, or else the number of bytes written.
 */


int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
{
	int ret;
	struct i2c_adapter *adap = client->adapter;
	struct i2c_msg msg;

	msg.addr = client->addr;
	msg.flags = client->flags & I2C_M_TEN;
	msg.len = count;
	msg.buf = (char *)buf;

	ret = i2c_transfer(adap, &msg, 1);

	/*
         * If everything went ok (i.e. 1 msg transmitted), return #bytes
         * transmitted, else error code.
         */
	return (ret == 1) ? count : ret;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
86
92.47%
1
20.00%
Greg Kroah-Hartman
4
4.30%
1
20.00%
Jean Delvare
2
2.15%
2
40.00%
Wolfram Sang
1
1.08%
1
20.00%
Total
93
100.00%
5
100.00%


EXPORT_SYMBOL(i2c_master_send);

/**
 * i2c_master_recv - issue a single I2C message in master receive mode
 * @client: Handle to slave device
 * @buf: Where to store data read from slave
 * @count: How many bytes to read, must be less than 64k since msg.len is u16
 *
 * Returns negative errno, or else the number of bytes read.
 */


int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
{
	struct i2c_adapter *adap = client->adapter;
	struct i2c_msg msg;
	int ret;

	msg.addr = client->addr;
	msg.flags = client->flags & I2C_M_TEN;
	msg.flags |= I2C_M_RD;
	msg.len = count;
	msg.buf = buf;

	ret = i2c_transfer(adap, &msg, 1);

	/*
         * If everything went ok (i.e. 1 msg received), return #bytes received,
         * else error code.
         */
	return (ret == 1) ? count : ret;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
91
96.81%
1
25.00%
Jean Delvare
2
2.13%
2
50.00%
Wolfram Sang
1
1.06%
1
25.00%
Total
94
100.00%
4
100.00%


EXPORT_SYMBOL(i2c_master_recv);

/* ----------------------------------------------------
 * the i2c address scanning function
 * Will not work for 10-bit addresses!
 * ----------------------------------------------------
 */

/*
 * Legacy default probe function, mostly relevant for SMBus. The default
 * probe method is a quick write, but it is known to corrupt the 24RF08
 * EEPROMs due to a state machine bug, and could also irreversibly
 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
 * we use a short byte read instead. Also, some bus drivers don't implement
 * quick write, so we fallback to a byte read in that case too.
 * On x86, there is another special case for FSC hardware monitoring chips,
 * which want regular byte reads (address 0x73.) Fortunately, these are the
 * only known chips using this I2C address on PC hardware.
 * Returns 1 if probe succeeded, 0 if not.
 */


static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
{
	int err;
	union i2c_smbus_data dummy;

#ifdef CONFIG_X86
	if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
	 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
		err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
				     I2C_SMBUS_BYTE_DATA, &dummy);
	else
#endif
	if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
	 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
		err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
				     I2C_SMBUS_QUICK, NULL);
	else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
		err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
				     I2C_SMBUS_BYTE, &dummy);
	else {
		dev_warn(&adap->dev, "No suitable probing method supported for address 0x%02X\n",
			 addr);
		err = -EOPNOTSUPP;
	}

	return err >= 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
170
98.27%
2
66.67%
Andrew Lutomirski
3
1.73%
1
33.33%
Total
173
100.00%
3
100.00%



static int i2c_detect_address(struct i2c_client *temp_client,
			      struct i2c_driver *driver)
{
	struct i2c_board_info info;
	struct i2c_adapter *adapter = temp_client->adapter;
	int addr = temp_client->addr;
	int err;

	/* Make sure the address is valid */
	err = i2c_check_7bit_addr_validity_strict(addr);
	if (err) {
		dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
			 addr);
		return err;
	}

	/* Skip if already in use (7 bit, no need to encode flags) */
	if (i2c_check_addr_busy(adapter, addr))
		return 0;

	/* Make sure there is something at this address */
	if (!i2c_default_probe(adapter, addr))
		return 0;

	/* Finally call the custom detection function */
	memset(&info, 0, sizeof(struct i2c_board_info));
	info.addr = addr;
	err = driver->detect(temp_client, &info);
	if (err) {
		/* -ENODEV is returned if the detection fails. We catch it
                   here as this isn't an error. */
		return err == -ENODEV ? 0 : err;
	}

	/* Consistency check */
	if (info.type[0] == '\0') {
		dev_err(&adapter->dev,
			"%s detection function provided no name for 0x%x\n",
			driver->driver.name, addr);
	} else {
		struct i2c_client *client;

		/* Detection succeeded, instantiate the device */
		if (adapter->class & I2C_CLASS_DEPRECATED)
			dev_warn(&adapter->dev,
				"This adapter will soon drop class based instantiation of devices. "
				"Please make sure client 0x%02x gets instantiated by other means. "
				"Check 'Documentation/i2c/instantiating-devices' for details.\n",
				info.addr);

		dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
			info.type, info.addr);
		client = i2c_new_device(adapter, &info);
		if (client)
			list_add_tail(&client->detected, &driver->clients);
		else
			dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
				info.type, info.addr);
	}
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
250
90.25%
6
60.00%
Wolfram Sang
26
9.39%
3
30.00%
Andy Shevchenko
1
0.36%
1
10.00%
Total
277
100.00%
10
100.00%



static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
{
	const unsigned short *address_list;
	struct i2c_client *temp_client;
	int i, err = 0;
	int adap_id = i2c_adapter_id(adapter);

	address_list = driver->address_list;
	if (!driver->detect || !address_list)
		return 0;

	/* Warn that the adapter lost class based instantiation */
	if (adapter->class == I2C_CLASS_DEPRECATED) {
		dev_dbg(&adapter->dev,
			"This adapter dropped support for I2C classes and won't auto-detect %s devices anymore. "
			"If you need it, check 'Documentation/i2c/instantiating-devices' for alternatives.\n",
			driver->driver.name);
		return 0;
	}

	/* Stop here if the classes do not match */
	if (!(adapter->class & driver->class))
		return 0;

	/* Set up a temporary client to help detect callback */
	temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
	if (!temp_client)
		return -ENOMEM;
	temp_client->adapter = adapter;

	for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
		dev_dbg(&adapter->dev,
			"found normal entry for adapter %d, addr 0x%02x\n",
			adap_id, address_list[i]);
		temp_client->addr = address_list[i];
		err = i2c_detect_address(temp_client, driver);
		if (unlikely(err))
			break;
	}

	kfree(temp_client);
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
176
84.62%
3
60.00%
Wolfram Sang
29
13.94%
1
20.00%
Andy Shevchenko
3
1.44%
1
20.00%
Total
208
100.00%
5
100.00%



int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
{
	return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
			      I2C_SMBUS_QUICK, NULL) >= 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
34
100.00%
1
100.00%
Total
34
100.00%
1
100.00%


EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);


struct i2c_client *

i2c_new_probed_device(struct i2c_adapter *adap,
		      struct i2c_board_info *info,
		      unsigned short const *addr_list,
		      int (*probe)(struct i2c_adapter *, unsigned short addr))
{
	int i;

	if (!probe)
		probe = i2c_default_probe;

	for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
		/* Check address validity */
		if (i2c_check_7bit_addr_validity_strict(addr_list[i]) < 0) {
			dev_warn(&adap->dev, "Invalid 7-bit address 0x%02x\n",
				 addr_list[i]);
			continue;
		}

		/* Check address availability (7 bit, no need to encode flags) */
		if (i2c_check_addr_busy(adap, addr_list[i])) {
			dev_dbg(&adap->dev,
				"Address 0x%02x already in use, not probing\n",
				addr_list[i]);
			continue;
		}

		/* Test address responsiveness */
		if (probe(adap, addr_list[i]))
			break;
	}

	if (addr_list[i] == I2C_CLIENT_END) {
		dev_dbg(&adap->dev, "Probing failed, no device found\n");
		return NULL;
	}

	info->addr = addr_list[i];
	return i2c_new_device(adap, info);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
181
97.84%
5
62.50%
Wolfram Sang
2
1.08%
2
25.00%
Andy Shevchenko
2
1.08%
1
12.50%
Total
185
100.00%
8
100.00%


EXPORT_SYMBOL_GPL(i2c_new_probed_device);



struct i2c_adapter *i2c_get_adapter(int nr)
{
	struct i2c_adapter *adapter;

	mutex_lock(&core_lock);
	adapter = idr_find(&i2c_adapter_idr, nr);
	if (!adapter)
		goto exit;

	if (try_module_get(adapter->owner))
		get_device(&adapter->dev);
	else
		adapter = NULL;

 exit:
	mutex_unlock(&core_lock);
	return adapter;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Gerd Knorr
31
43.06%
1
14.29%
Vladimir Zapolskiy
18
25.00%
1
14.29%
Mark M. Hoffman
9
12.50%
1
14.29%
Linus Torvalds (pre-git)
8
11.11%
1
14.29%
Jean Delvare
4
5.56%
2
28.57%
Arjan van de Ven
2
2.78%
1
14.29%
Total
72
100.00%
7
100.00%


EXPORT_SYMBOL(i2c_get_adapter);



void i2c_put_adapter(struct i2c_adapter *adap)
{
	if (!adap)
		return;

	put_device(&adap->dev);
	module_put(adap->owner);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Gerd Knorr
17
54.84%
1
33.33%
Vladimir Zapolskiy
10
32.26%
1
33.33%
Sebastian Hesselbarth
4
12.90%
1
33.33%
Total
31
100.00%
3
100.00%


EXPORT_SYMBOL(i2c_put_adapter);

/* The SMBus parts */


#define POLY    (0x1070U << 3)


static u8 crc8(u16 data)
{
	int i;

	for (i = 0; i < 8; i++) {
		if (data & 0x8000)
			data = data ^ POLY;
		data = data << 1;
	}
	return (u8)(data >> 8);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Albert Cranford
47
85.45%
1
50.00%
Linus Torvalds (pre-git)
8
14.55%
1
50.00%
Total
55
100.00%
2
100.00%

/* Incremental CRC8 over count bytes in the array pointed to by p */


static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
{
	int i;

	for (i = 0; i < count; i++)
		crc = crc8((crc ^ p[i]) << 8);
	return crc;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Albert Cranford
36
70.59%
1
25.00%
Linus Torvalds (pre-git)
9
17.65%
1
25.00%
Jean Delvare
5
9.80%
1
25.00%
Adrian Bunk
1
1.96%
1
25.00%
Total
51
100.00%
4
100.00%

/* Assume a 7-bit address, which is reasonable for SMBus */


static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
{
	/* The address will be sent first */
	u8 addr = i2c_8bit_addr_from_msg(msg);
	pec = i2c_smbus_pec(pec, &addr, 1);

	/* The data buffer follows */
	return i2c_smbus_pec(pec, msg->buf, msg->len);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
24
48.00%
1
20.00%
Albert Cranford
20
40.00%
1
20.00%
Wolfram Sang
3
6.00%
1
20.00%
Linus Torvalds (pre-git)
2
4.00%
1
20.00%
Adrian Bunk
1
2.00%
1
20.00%
Total
50
100.00%
5
100.00%

/* Used for write only transactions */


static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
{
	msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
	msg->len++;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
24
72.73%
1
50.00%
Albert Cranford
9
27.27%
1
50.00%
Total
33
100.00%
2
100.00%

/* Return <0 on CRC error
   If there was a write before this read (most cases) we need to take the
   partial CRC from the write part into account.
   Note that this function does modify the message (we need to decrease the
   message length to hide the CRC byte from the caller). */


static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
{
	u8 rpec = msg->buf[--msg->len];
	cpec = i2c_smbus_msg_pec(cpec, msg);

	if (rpec != cpec) {
		pr_debug("Bad PEC 0x%02x vs. 0x%02x\n",
			rpec, cpec);
		return -EBADMSG;
	}
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Albert Cranford
30
50.00%
1
20.00%
Jean Delvare
27
45.00%
1
20.00%
Greg Kroah-Hartman
1
1.67%
1
20.00%
David Brownell
1
1.67%
1
20.00%
Wolfram Sang
1
1.67%
1
20.00%
Total
60
100.00%
5
100.00%

/**
 * i2c_smbus_read_byte - SMBus "receive byte" protocol
 * @client: Handle to slave device
 *
 * This executes the SMBus "receive byte" protocol, returning negative errno
 * else the byte received from the device.
 */


s32 i2c_smbus_read_byte(const struct i2c_client *client)
{
	union i2c_smbus_data data;
	int status;

	status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
				I2C_SMBUS_READ, 0,
				I2C_SMBUS_BYTE, &data);
	return (status < 0) ? status : data.byte;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Albert Cranford
42
73.68%
1
33.33%
David Brownell
14
24.56%
1
33.33%
Jean Delvare
1
1.75%
1
33.33%
Total
57
100.00%
3
100.00%


EXPORT_SYMBOL(i2c_smbus_read_byte);

/**
 * i2c_smbus_write_byte - SMBus "send byte" protocol
 * @client: Handle to slave device
 * @value: Byte to be sent
 *
 * This executes the SMBus "send byte" protocol, returning negative errno
 * else zero on success.
 */


s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
{
	return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
	                      I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Albert Cranford
36
94.74%
1
33.33%
Jean Delvare
2
5.26%
2
66.67%
Total
38
100.00%
3
100.00%


EXPORT_SYMBOL(i2c_smbus_write_byte);

/**
 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
 * @client: Handle to slave device
 * @command: Byte interpreted by slave
 *
 * This executes the SMBus "read byte" protocol, returning negative errno
 * else a data byte received from the device.
 */


s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
{
	union i2c_smbus_data data;
	int status;

	status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
				I2C_SMBUS_READ, command,
				I2C_SMBUS_BYTE_DATA, &data);
	return (status < 0) ? status : data.byte;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Albert Cranford
26
43.33%
1
25.00%
Linus Torvalds (pre-git)
19
31.67%
1
25.00%
David Brownell
14
23.33%
1
25.00%
Jean Delvare
1
1.67%
1
25.00%
Total
60
100.00%
4
100.00%


EXPORT_SYMBOL(i2c_smbus_read_byte_data);

/**
 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
 * @client: Handle to slave device
 * @command: Byte interpreted by slave
 * @value: Byte being written
 *
 * This executes the SMBus "write byte" protocol, returning negative errno
 * else zero on success.
 */


s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
			      u8 value)
{
	union i2c_smbus_data data;
	data.byte = value;
	return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
			      I2C_SMBUS_WRITE, command,
			      I2C_SMBUS_BYTE_DATA, &data);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
51
98.08%
1
50.00%
Jean Delvare
1
1.92%
1
50.00%
Total
52
100.00%
2
100.00%


EXPORT_SYMBOL(i2c_smbus_write_byte_data);

/**
 * i2c_smbus_read_word_data - SMBus "read word" protocol
 * @client: Handle to slave device
 * @command: Byte interpreted by slave
 *
 * This executes the SMBus "read word" protocol, returning negative errno
 * else a 16-bit unsigned "word" received from the device.
 */


s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
{
	union i2c_smbus_data data;
	int status;

	status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
				I2C_SMBUS_READ, command,
				I2C_SMBUS_WORD_DATA, &data);
	return (status < 0) ? status : data.word;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
45
75.00%
1
33.33%
David Brownell
14
23.33%
1
33.33%
Jean Delvare
1
1.67%
1
33.33%
Total
60
100.00%
3
100.00%


EXPORT_SYMBOL(i2c_smbus_read_word_data);

/**
 * i2c_smbus_write_word_data - SMBus "write word" protocol
 * @client: Handle to slave device
 * @command: Byte interpreted by slave
 * @value: 16-bit "word" being written
 *
 * This executes the SMBus "write word" protocol, returning negative errno
 * else zero on success.
 */


s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
			      u16 value)
{
	union i2c_smbus_data data;
	data.word = value;
	return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
			      I2C_SMBUS_WRITE, command,
			      I2C_SMBUS_WORD_DATA, &data);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
51
98.08%
1
50.00%
Jean Delvare
1
1.92%
1
50.00%
Total
52
100.00%
2
100.00%


EXPORT_SYMBOL(i2c_smbus_write_word_data);

/**
 * i2c_smbus_read_block_data - SMBus "block read" protocol
 * @client: Handle to slave device
 * @command: Byte interpreted by slave
 * @values: Byte array into which data will be read; big enough to hold
 *      the data returned by the slave.  SMBus allows at most 32 bytes.
 *
 * This executes the SMBus "block read" protocol, returning negative errno
 * else the number of data bytes in the slave's response.
 *
 * Note that using this function requires that the client's adapter support
 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality.  Not all adapter drivers
 * support this; its emulation through I2C messaging relies on a specific
 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
 */


s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
			      u8 *values)
{
	union i2c_smbus_data data;
	int status;

	status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
				I2C_SMBUS_READ, command,
				I2C_SMBUS_BLOCK_DATA, &data);
	if (status)
		return status;

	memcpy(values, &data.block[1], data.block[0]);
	return data.block[0];
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
76
88.37%
2
66.67%
David Brownell
10
11.63%
1
33.33%
Total
86
100.00%
3
100.00%


EXPORT_SYMBOL(i2c_smbus_read_block_data);

/**
 * i2c_smbus_write_block_data - SMBus "block write" protocol
 * @client: Handle to slave device
 * @command: Byte interpreted by slave
 * @length: Size of data block; SMBus allows at most 32 bytes
 * @values: Byte array which will be written.
 *
 * This executes the SMBus "block write" protocol, returning negative errno
 * else zero on success.
 */


s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
			       u8 length, const u8 *values)
{
	union i2c_smbus_data data;

	if (length > I2C_SMBUS_BLOCK_MAX)
		length = I2C_SMBUS_BLOCK_MAX;
	data.block[0] = length;
	memcpy(&data.block[1], values, length);
	return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
			      I2C_SMBUS_WRITE, command,
			      I2C_SMBUS_BLOCK_DATA, &data);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Gabriel Paubert
73
85.88%
1
25.00%
Jean Delvare
11
12.94%
2
50.00%
Krzysztof Hałasa
1
1.18%
1
25.00%
Total
85
100.00%
4
100.00%


EXPORT_SYMBOL(i2c_smbus_write_block_data);

/* Returns the number of read bytes */


s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
				  u8 length, u8 *values)
{
	union i2c_smbus_data data;
	int status;

	if (length > I2C_SMBUS_BLOCK_MAX)
		length = I2C_SMBUS_BLOCK_MAX;
	data.block[0] = length;
	status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
				I2C_SMBUS_READ, command,
				I2C_SMBUS_I2C_BLOCK_DATA, &data);
	if (status < 0)
		return status;

	memcpy(values, &data.block[1], data.block[0]);
	return data.block[0];
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Albert Cranford
69
62.73%
1
20.00%
Jean Delvare
29
26.36%
3
60.00%
David Brownell
12
10.91%
1
20.00%
Total
110
100.00%
5
100.00%


EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);



s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
				   u8 length, const u8 *values)
{
	union i2c_smbus_data data;

	if (length > I2C_SMBUS_BLOCK_MAX)
		length = I2C_SMBUS_BLOCK_MAX;
	data.block[0] = length;
	memcpy(data.block + 1, values, length);
	return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
			      I2C_SMBUS_WRITE, command,
			      I2C_SMBUS_I2C_BLOCK_DATA, &data);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
82
98.80%
2
66.67%
Krzysztof Hałasa
1
1.20%
1
33.33%
Total
83
100.00%
3
100.00%


EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);

/* Simulate a SMBus command using the i2c protocol
   No checking of parameters is done!  */


static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
				   unsigned short flags,
				   char read_write, u8 command, int size,
				   union i2c_smbus_data *data)
{
	/* So we need to generate a series of msgs. In the case of writing, we
          need to use only one message; when reading, we need two. We initialize
          most things with sane defaults, to keep the code below somewhat
          simpler. */
	unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
	unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
	int num = read_write == I2C_SMBUS_READ ? 2 : 1;
	int i;
	u8 partial_pec = 0;
	int status;
	struct i2c_msg msg[2] = {
		{
			.addr = addr,
			.flags = flags,
			.len = 1,
			.buf = msgbuf0,
                }, {
			.addr = addr,
			.flags = flags | I2C_M_RD,
			.len = 0,
			.buf = msgbuf1,
                },
        };

	msgbuf0[0] = command;
	switch (size) {
	case I2C_SMBUS_QUICK:
		msg[0].len = 0;
		/* Special case: The read/write field is used as data */
		msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
					I2C_M_RD : 0);
		num = 1;
		break;
	case I2C_SMBUS_BYTE:
		if (read_write == I2C_SMBUS_READ) {
			/* Special case: only a read! */
			msg[0].flags = I2C_M_RD | flags;
			num = 1;
		}
		break;
	case I2C_SMBUS_BYTE_DATA:
		if (read_write == I2C_SMBUS_READ)
			msg[1].len = 1;
		else {
			msg[0].len = 2;
			msgbuf0[1] = data->byte;
		}
		break;
	case I2C_SMBUS_WORD_DATA:
		if (read_write == I2C_SMBUS_READ)
			msg[1].len = 2;
		else {
			msg[0].len = 3;
			msgbuf0[1] = data->word & 0xff;
			msgbuf0[2] = data->word >> 8;
		}
		break;
	case I2C_SMBUS_PROC_CALL:
		num = 2; /* Special case */
		read_write = I2C_SMBUS_READ;
		msg[0].len = 3;
		msg[1].len = 2;
		msgbuf0[1] = data->word & 0xff;
		msgbuf0[2] = data->word >> 8;
		break;
	case I2C_SMBUS_BLOCK_DATA:
		if (read_write == I2C_SMBUS_READ) {
			msg[1].flags |= I2C_M_RECV_LEN;
			msg[1].len = 1; /* block length will be added by
                                           the underlying bus driver */
		} else {
			msg[0].len = data->block[0] + 2;
			if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
				dev_err(&adapter->dev,
					"Invalid block write size %d\n",
					data->block[0]);
				return -EINVAL;
			}
			for (i = 1; i < msg[0].len; i++)
				msgbuf0[i] = data->block[i-1];
		}
		break;
	case I2C_SMBUS_BLOCK_PROC_CALL:
		num = 2; /* Another special case */
		read_write = I2C_SMBUS_READ;
		if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
			dev_err(&adapter->dev,
				"Invalid block write size %d\n",
				data->block[0]);
			return -EINVAL;
		}
		msg[0].len = data->block[0] + 2;
		for (i = 1; i < msg[0].len; i++)
			msgbuf0[i] = data->block[i-1];
		msg[1].flags |= I2C_M_RECV_LEN;
		msg[1].len = 1; /* block length will be added by
                                   the underlying bus driver */
		break;
	case I2C_SMBUS_I2C_BLOCK_DATA:
		if (read_write == I2C_SMBUS_READ) {
			msg[1].len = data->block[0];
		} else {
			msg[0].len = data->block[0] + 1;
			if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
				dev_err(&adapter->dev,
					"Invalid block write size %d\n",
					data->block[0]);
				return -EINVAL;
			}
			for (i = 1; i <= data->block[0]; i++)
				msgbuf0[i] = data->block[i];
		}
		break;
	default:
		dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
		return -EOPNOTSUPP;
	}

	i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
				      && size != I2C_SMBUS_I2C_BLOCK_DATA);
	if (i) {
		/* Compute PEC if first message is a write */
		if (!(msg[0].flags & I2C_M_RD)) {
			if (num == 1) /* Write only */
				i2c_smbus_add_pec(&msg[0]);
			else /* Write followed by read */
				partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
		}
		/* Ask for PEC if last message is a read */
		if (msg[num-1].flags & I2C_M_RD)
			msg[num-1].len++;
	}

	status = i2c_transfer(adapter, msg, num);
	if (status < 0)
		return status;

	/* Check PEC if last message is a read */
	if (i && (msg[num-1].flags & I2C_M_RD)) {
		status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
		if (status < 0)
			return status;
	}

	if (read_write == I2C_SMBUS_READ)
		switch (size) {
		case I2C_SMBUS_BYTE:
			data->byte = msgbuf0[0];
			break;
		case I2C_SMBUS_BYTE_DATA:
			data->byte = msgbuf1[0];
			break;
		case I2C_SMBUS_WORD_DATA:
		case I2C_SMBUS_PROC_CALL:
			data->word = msgbuf1[0] | (msgbuf1[1] << 8);
			break;
		case I2C_SMBUS_I2C_BLOCK_DATA:
			for (i = 0; i < data->block[0]; i++)
				data->block[i+1] = msgbuf1[i];
			break;
		case I2C_SMBUS_BLOCK_DATA:
		case I2C_SMBUS_BLOCK_PROC_CALL:
			for (i = 0; i < msgbuf1[0] + 1; i++)
				data->block[i] = msgbuf1[i];
			break;
		}
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
470
46.49%
2
14.29%
Jean Delvare
327
32.34%
4
28.57%
Albert Cranford
124
12.27%
2
14.29%
Shubhrajyoti Datta
38
3.76%
1
7.14%
David Brownell
23
2.27%
1
7.14%
Greg Kroah-Hartman
19
1.88%
1
7.14%
Hideki Iwamoto
7
0.69%
1
7.14%
Pavel Machek
2
0.20%
1
7.14%
Roel Kluin
1
0.10%
1
7.14%
Total
1011
100.00%
14
100.00%

/**
 * i2c_smbus_xfer - execute SMBus protocol operations
 * @adapter: Handle to I2C bus
 * @addr: Address of SMBus slave on that bus
 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
 * @command: Byte interpreted by slave, for protocols which use such bytes
 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
 * @data: Data to be read or written
 *
 * This executes an SMBus protocol operation, and returns a negative
 * errno code else zero on success.
 */


s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
		   char read_write, u8 command, int protocol,
		   union i2c_smbus_data *data)
{
	unsigned long orig_jiffies;
	int try;
	s32 res;

	/* If enabled, the following two tracepoints are conditional on
         * read_write and protocol.
         */
	trace_smbus_write(adapter, addr, flags, read_write,
			  command, protocol, data);
	trace_smbus_read(adapter, addr, flags, read_write,
			 command, protocol);

	flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;

	if (adapter->algo->smbus_xfer) {
		i2c_lock_bus(adapter, I2C_LOCK_SEGMENT);

		/* Retry automatically on arbitration loss */
		orig_jiffies = jiffies;
		for (res = 0, try = 0; try <= adapter->retries; try++) {
			res = adapter->algo->smbus_xfer(adapter, addr, flags,
							read_write, command,
							protocol, data);
			if (res != -EAGAIN)
				break;
			if (time_after(jiffies,
				       orig_jiffies + adapter->timeout))
				break;
		}
		i2c_unlock_bus(adapter, I2C_LOCK_SEGMENT);

		if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
			goto trace;
		/*
                 * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
                 * implement native support for the SMBus operation.
                 */
	}

	res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
				      command, protocol, data);

trace:
	/* If enabled, the reply tracepoint is conditional on read_write. */
	trace_smbus_reply(adapter, addr, flags, read_write,
			  command, protocol, data);
	trace_smbus_result(adapter, addr, flags, read_write,
			   command, protocol, res);

	return res;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
88
34.65%
1
12.50%
David Howells
78
30.71%
1
12.50%
Clifford Wolf
55
21.65%
1
12.50%
Laurent Pinchart
17
6.69%
2
25.00%
Albert Cranford
7
2.76%
1
12.50%
Peter Rosin
6
2.36%
1
12.50%
David Brownell
3
1.18%
1
12.50%
Total
254
100.00%
8
100.00%


EXPORT_SYMBOL(i2c_smbus_xfer);

/**
 * i2c_smbus_read_i2c_block_data_or_emulated - read block or emulate
 * @client: Handle to slave device
 * @command: Byte interpreted by slave
 * @length: Size of data block; SMBus allows at most I2C_SMBUS_BLOCK_MAX bytes
 * @values: Byte array into which data will be read; big enough to hold
 *      the data returned by the slave.  SMBus allows at most
 *      I2C_SMBUS_BLOCK_MAX bytes.
 *
 * This executes the SMBus "block read" protocol if supported by the adapter.
 * If block read is not supported, it emulates it using either word or byte
 * read protocols depending on availability.
 *
 * The addresses of the I2C slave device that are accessed with this function
 * must be mapped to a linear region, so that a block read will have the same
 * effect as a byte read. Before using this function you must double-check
 * if the I2C slave does support exchanging a block transfer with a byte
 * transfer.
 */


s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
					      u8 command, u8 length, u8 *values)
{
	u8 i = 0;
	int status;

	if (length > I2C_SMBUS_BLOCK_MAX)
		length = I2C_SMBUS_BLOCK_MAX;

	if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
		return i2c_smbus_read_i2c_block_data(client, command, length, values);

	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA))
		return -EOPNOTSUPP;

	if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_WORD_DATA)) {
		while ((i + 2) <= length) {
			status = i2c_smbus_read_word_data(client, command + i);
			if (status < 0)
				return status;
			values[i] = status & 0xff;
			values[i + 1] = status >> 8;
			i += 2;
		}
	}

	while (i < length) {
		status = i2c_smbus_read_byte_data(client, command + i);
		if (status < 0)
			return status;
		values[i] = status;
		i++;
	}

	return i;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Irina Tirdea
188
100.00%
1
100.00%
Total
188
100.00%
1
100.00%


EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data_or_emulated);

#if IS_ENABLED(CONFIG_I2C_SLAVE)


int i2c_slave_register(struct i2c_client *client, i2c_slave_cb_t slave_cb)
{
	int ret;

	if (!client || !slave_cb) {
		WARN(1, "insufficient data\n");
		return -EINVAL;
	}

	if (!(client->flags & I2C_CLIENT_SLAVE))
		dev_warn(&client->dev, "%s: client slave flag not set. You might see address collisions\n",
			 __func__);

	if (!(client->flags & I2C_CLIENT_TEN)) {
		/* Enforce stricter address checking */
		ret = i2c_check_7bit_addr_validity_strict(client->addr);
		if (ret) {
			dev_err(&client->dev, "%s: invalid address\n", __func__);
			return ret;
		}
	}

	if (!client->adapter->algo->reg_slave) {
		dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
		return -EOPNOTSUPP;
	}

	client->slave_cb = slave_cb;

	i2c_lock_adapter(client->adapter);
	ret = client->adapter->algo->reg_slave(client);
	i2c_unlock_adapter(client->adapter);

	if (ret) {
		client->slave_cb = NULL;
		dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
	}

	return ret;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Wolfram Sang
194
99.49%
4
80.00%
Colin Ian King
1
0.51%
1
20.00%
Total
195
100.00%
5
100.00%


EXPORT_SYMBOL_GPL(i2c_slave_register);



int i2c_slave_unregister(struct i2c_client *client)
{
	int ret;

	if (!client->adapter->algo->unreg_slave) {
		dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
		return -EOPNOTSUPP;
	}

	i2c_lock_adapter(client->adapter);
	ret = client->adapter->algo->unreg_slave(client);
	i2c_unlock_adapter(client->adapter);

	if (ret == 0)
		client->slave_cb = NULL;
	else
		dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);

	return ret;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Wolfram Sang
99
100.00%
2
100.00%
Total
99
100.00%
2
100.00%


EXPORT_SYMBOL_GPL(i2c_slave_unregister);

/**
 * i2c_detect_slave_mode - detect operation mode
 * @dev: The device owning the bus
 *
 * This checks the device nodes for an I2C slave by checking the address
 * used in the reg property. If the address match the I2C_OWN_SLAVE_ADDRESS
 * flag this means the device is configured to act as a I2C slave and it will
 * be listening at that address.
 *
 * Returns true if an I2C own slave address is detected, otherwise returns
 * false.
 */


bool i2c_detect_slave_mode(struct device *dev)
{
	if (IS_BUILTIN(CONFIG_OF) && dev->of_node) {
		struct device_node *child;
		u32 reg;

		for_each_child_of_node(dev->of_node, child) {
			of_property_read_u32(child, "reg", &reg);
			if (reg & I2C_OWN_SLAVE_ADDRESS) {
				of_node_put(child);
				return true;
			}
		}
	} else if (IS_BUILTIN(CONFIG_ACPI) && ACPI_HANDLE(dev)) {
		dev_dbg(dev, "ACPI slave is not supported yet\n");
	}
	return false;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Luis Oliveira
90
100.00%
1
100.00%
Total
90
100.00%
1
100.00%


EXPORT_SYMBOL_GPL(i2c_detect_slave_mode);

#endif

MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
MODULE_DESCRIPTION("I2C-Bus main module");
MODULE_LICENSE("GPL");
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
3711
24.54%
64
25.40%
Wolfram Sang
3269
21.62%
34
13.49%
Linus Torvalds (pre-git)
1110
7.34%
4
1.59%
David Brownell
1063
7.03%
17
6.75%
Octavian Purdila
606
4.01%
1
0.40%
Jarkko Nikula
482
3.19%
4
1.59%
Viresh Kumar
479
3.17%
1
0.40%
Albert Cranford
451
2.98%
2
0.79%
Pantelis Antoniou
384
2.54%
3
1.19%
Benjamin Tissoires
363
2.40%
1
0.40%
Dmitry Torokhov
274
1.81%
3
1.19%
David Howells
245
1.62%
2
0.79%
Lee Jones
239
1.58%
6
2.38%
Mika Westerberg
238
1.57%
5
1.98%
Greg Kroah-Hartman
198
1.31%
12
4.76%
Irina Tirdea
194
1.28%
1
0.40%
Vladimir Zapolskiy
141
0.93%
4
1.59%
Michael Lawnick
136
0.90%
1
0.40%
Gerd Knorr
121
0.80%
2
0.79%
Douglas Anderson
112
0.74%
1
0.40%
Jean-Michel Hautbois
106
0.70%
1
0.40%
Luis Oliveira
96
0.63%
1
0.40%
Peter Rosin
80
0.53%
4
1.59%
Gabriel Paubert
73
0.48%
1
0.40%
Clifford Wolf
63
0.42%
1
0.40%
Laurent Pinchart
50
0.33%
3
1.19%
Rui Zhang
48
0.32%
1
0.40%
Ralf Ramsauer
46
0.30%
1
0.40%
Peter Hüwe
45
0.30%
1
0.40%
Dave Young
38
0.25%
1
0.40%
Adrian Bunk
38
0.25%
2
0.79%
Shubhrajyoti Datta
38
0.25%
1
0.40%
Jon Hunter
38
0.25%
1
0.40%
Lars-Peter Clausen
36
0.24%
3
1.19%
Stephen Warren
35
0.23%
1
0.40%
Mike Rapoport
33
0.22%
1
0.40%
Russell King
28
0.19%
1
0.40%
Lv Zheng
27
0.18%
1
0.40%
Faik Uygur
27
0.18%
1
0.40%
Grant C. Likely
27
0.18%
3
1.19%
Christoph Hellwig
23
0.15%
3
1.19%
Sylwester Nawrocki
19
0.13%
1
0.40%
Marc Pignat
19
0.13%
1
0.40%
Tejun Heo
17
0.11%
1
0.40%
Anton Vorontsov
17
0.11%
1
0.40%
Mark Brown
17
0.11%
2
0.79%
Thadeu Lima de Souza Cascardo
15
0.10%
1
0.40%
Bartosz Golaszewski
14
0.09%
2
0.79%
Jan Lübbe
14
0.09%
1
0.40%
Ulf Hansson
13
0.09%
2
0.79%
Geert Uytterhoeven
13
0.09%
1
0.40%
Lan Tianyu
13
0.09%
2
0.79%
Linus Walleij
10
0.07%
1
0.40%
Andy Shevchenko
10
0.07%
1
0.40%
Mark M. Hoffman
9
0.06%
1
0.40%
Rafael J. Wysocki
9
0.06%
2
0.79%
Charles Keepax
8
0.05%
1
0.40%
Arjan van de Ven
7
0.05%
1
0.40%
Hans Verkuil
7
0.05%
1
0.40%
Hideki Iwamoto
7
0.05%
1
0.40%
Dan O'Donovan
6
0.04%
1
0.40%
Sudip Mukherjee
6
0.04%
1
0.40%
Zhenwen Xu
6
0.04%
1
0.40%
Grygorii Strashko
5
0.03%
2
0.79%
Jon Smirl
5
0.03%
1
0.40%
Kay Sievers
5
0.03%
2
0.79%
Laurent Riffard
5
0.03%
1
0.40%
Kieran Bingham
4
0.03%
1
0.40%
Rodolfo Giometti
4
0.03%
1
0.40%
Steven Rostedt
4
0.03%
1
0.40%
Sebastian Hesselbarth
4
0.03%
1
0.40%
Andrew Lutomirski
3
0.02%
1
0.40%
Krzysztof Hałasa
2
0.01%
1
0.40%
Zhangfei Gao
2
0.01%
1
0.40%
Pavel Machek
2
0.01%
1
0.40%
Shailendra Verma
1
0.01%
1
0.40%
Linus Torvalds
1
0.01%
1
0.40%
Roel Kluin
1
0.01%
1
0.40%
Mickey Stein
1
0.01%
1
0.40%
Lucas De Marchi
1
0.01%
1
0.40%
Matthias Kaehlcke
1
0.01%
1
0.40%
Alexander Sverdlin
1
0.01%
1
0.40%
Mika Kuoppala
1
0.01%
1
0.40%
Andreas Schultz
1
0.01%
1
0.40%
Colin Ian King
1
0.01%
1
0.40%
Total
15122
100.00%
252
100.00%
Directory: drivers/i2c

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.