2005-04-17 06:20:36 +08:00
|
|
|
/* 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.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program; if not, write to the Free Software
|
2012-03-27 03:47:19 +08:00
|
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
|
|
|
MA 02110-1301 USA. */
|
2005-04-17 06:20:36 +08:00
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
|
2007-10-20 05:21:04 +08:00
|
|
|
/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>.
|
2005-04-17 06:20:36 +08:00
|
|
|
All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl>
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-27 03:28:55 +08:00
|
|
|
SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and
|
2014-01-30 03:40:08 +08:00
|
|
|
Jean Delvare <jdelvare@suse.de>
|
2010-08-12 00:21:02 +08:00
|
|
|
Mux support by Rodolfo Giometti <giometti@enneenne.com> and
|
2013-07-11 19:56:15 +08:00
|
|
|
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>
|
2014-09-23 01:41:00 +08:00
|
|
|
I2C ACPI code Copyright (C) 2014 Intel Corp
|
|
|
|
Author: Lan Tianyu <tianyu.lan@intel.com>
|
2013-07-11 19:56:15 +08:00
|
|
|
*/
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/kernel.h>
|
2012-02-28 20:56:31 +08:00
|
|
|
#include <linux/delay.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/errno.h>
|
2012-02-28 20:56:31 +08:00
|
|
|
#include <linux/gpio.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/i2c.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/idr.h>
|
2006-01-11 17:50:26 +08:00
|
|
|
#include <linux/mutex.h>
|
2013-07-11 19:56:15 +08:00
|
|
|
#include <linux/of.h>
|
2010-06-08 21:48:19 +08:00
|
|
|
#include <linux/of_device.h>
|
2013-07-11 19:56:15 +08:00
|
|
|
#include <linux/of_irq.h>
|
2014-06-18 23:29:32 +08:00
|
|
|
#include <linux/clk/clk-conf.h>
|
2007-02-14 05:09:00 +08:00
|
|
|
#include <linux/completion.h>
|
2008-01-28 01:14:50 +08:00
|
|
|
#include <linux/hardirq.h>
|
|
|
|
#include <linux/irqflags.h>
|
2009-06-19 22:58:20 +08:00
|
|
|
#include <linux/rwsem.h>
|
2010-03-02 19:23:46 +08:00
|
|
|
#include <linux/pm_runtime.h>
|
2012-11-23 19:23:40 +08:00
|
|
|
#include <linux/acpi.h>
|
2014-03-06 21:35:59 +08:00
|
|
|
#include <linux/jump_label.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <asm/uaccess.h>
|
|
|
|
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-02 05:26:31 +08:00
|
|
|
#include "i2c-core.h"
|
|
|
|
|
2014-03-06 21:35:59 +08:00
|
|
|
#define CREATE_TRACE_POINTS
|
|
|
|
#include <trace/events/i2c.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-05-04 17:09:28 +08:00
|
|
|
/* core_lock protects i2c_adapter_idr, and guarantees
|
2009-06-19 22:58:19 +08:00
|
|
|
that device detection, deletion of detected devices, and attach_adapter
|
2013-03-09 16:16:44 +08:00
|
|
|
calls are serialized */
|
2008-01-28 01:14:49 +08:00
|
|
|
static DEFINE_MUTEX(core_lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
static DEFINE_IDR(i2c_adapter_idr);
|
|
|
|
|
2009-09-19 04:45:46 +08:00
|
|
|
static struct device_type i2c_client_type;
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-15 04:38:36 +08:00
|
|
|
static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
|
2007-02-14 05:09:00 +08:00
|
|
|
|
2014-03-06 21:35:59 +08:00
|
|
|
static struct static_key i2c_trace_msg = STATIC_KEY_INIT_FALSE;
|
|
|
|
|
|
|
|
void i2c_transfer_trace_reg(void)
|
|
|
|
{
|
|
|
|
static_key_slow_inc(&i2c_trace_msg);
|
|
|
|
}
|
|
|
|
|
|
|
|
void i2c_transfer_trace_unreg(void)
|
|
|
|
{
|
|
|
|
static_key_slow_dec(&i2c_trace_msg);
|
|
|
|
}
|
|
|
|
|
2014-09-23 01:41:00 +08:00
|
|
|
#if defined(CONFIG_ACPI)
|
|
|
|
struct acpi_i2c_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;
|
|
|
|
|
|
|
|
static int acpi_i2c_add_resource(struct acpi_resource *ares, void *data)
|
|
|
|
{
|
|
|
|
struct i2c_board_info *info = data;
|
|
|
|
|
|
|
|
if (ares->type == ACPI_RESOURCE_TYPE_SERIAL_BUS) {
|
|
|
|
struct acpi_resource_i2c_serialbus *sb;
|
|
|
|
|
|
|
|
sb = &ares->data.i2c_serial_bus;
|
|
|
|
if (sb->type == ACPI_RESOURCE_SERIAL_TYPE_I2C) {
|
|
|
|
info->addr = sb->slave_address;
|
|
|
|
if (sb->access_mode == ACPI_I2C_10BIT_MODE)
|
|
|
|
info->flags |= I2C_CLIENT_TEN;
|
|
|
|
}
|
|
|
|
} else if (info->irq < 0) {
|
|
|
|
struct resource r;
|
|
|
|
|
|
|
|
if (acpi_dev_resource_interrupt(ares, 0, &r))
|
|
|
|
info->irq = r.start;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Tell the ACPI core to skip this resource */
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static acpi_status acpi_i2c_add_device(acpi_handle handle, u32 level,
|
|
|
|
void *data, void **return_value)
|
|
|
|
{
|
|
|
|
struct i2c_adapter *adapter = data;
|
|
|
|
struct list_head resource_list;
|
|
|
|
struct i2c_board_info info;
|
|
|
|
struct acpi_device *adev;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (acpi_bus_get_device(handle, &adev))
|
|
|
|
return AE_OK;
|
|
|
|
if (acpi_bus_get_status(adev) || !adev->status.present)
|
|
|
|
return AE_OK;
|
|
|
|
|
|
|
|
memset(&info, 0, sizeof(info));
|
|
|
|
info.acpi_node.companion = adev;
|
|
|
|
info.irq = -1;
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&resource_list);
|
|
|
|
ret = acpi_dev_get_resources(adev, &resource_list,
|
|
|
|
acpi_i2c_add_resource, &info);
|
|
|
|
acpi_dev_free_resource_list(&resource_list);
|
|
|
|
|
|
|
|
if (ret < 0 || !info.addr)
|
|
|
|
return AE_OK;
|
|
|
|
|
|
|
|
adev->power.flags.ignore_parent = true;
|
|
|
|
strlcpy(info.type, dev_name(&adev->dev), sizeof(info.type));
|
|
|
|
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));
|
|
|
|
}
|
|
|
|
|
|
|
|
return AE_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* acpi_i2c_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 acpi_i2c_register_devices(struct i2c_adapter *adap)
|
|
|
|
{
|
|
|
|
acpi_handle handle;
|
|
|
|
acpi_status status;
|
|
|
|
|
|
|
|
if (!adap->dev.parent)
|
|
|
|
return;
|
|
|
|
|
|
|
|
handle = ACPI_HANDLE(adap->dev.parent);
|
|
|
|
if (!handle)
|
|
|
|
return;
|
|
|
|
|
|
|
|
status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
|
|
|
|
acpi_i2c_add_device, NULL,
|
|
|
|
adap, NULL);
|
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
dev_warn(&adap->dev, "failed to enumerate I2C slaves\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
#else /* CONFIG_ACPI */
|
|
|
|
static inline void acpi_i2c_register_devices(struct i2c_adapter *adap) { }
|
|
|
|
#endif /* CONFIG_ACPI */
|
|
|
|
|
|
|
|
#ifdef CONFIG_ACPI_I2C_OPREGION
|
|
|
|
static int acpi_gsb_i2c_read_bytes(struct i2c_client *client,
|
|
|
|
u8 cmd, u8 *data, u8 data_len)
|
|
|
|
{
|
|
|
|
|
|
|
|
struct i2c_msg msgs[2];
|
|
|
|
int ret;
|
|
|
|
u8 *buffer;
|
|
|
|
|
|
|
|
buffer = kzalloc(data_len, GFP_KERNEL);
|
|
|
|
if (!buffer)
|
|
|
|
return AE_NO_MEMORY;
|
|
|
|
|
|
|
|
msgs[0].addr = client->addr;
|
|
|
|
msgs[0].flags = client->flags;
|
|
|
|
msgs[0].len = 1;
|
|
|
|
msgs[0].buf = &cmd;
|
|
|
|
|
|
|
|
msgs[1].addr = client->addr;
|
|
|
|
msgs[1].flags = client->flags | I2C_M_RD;
|
|
|
|
msgs[1].len = data_len;
|
|
|
|
msgs[1].buf = buffer;
|
|
|
|
|
|
|
|
ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
|
|
|
|
if (ret < 0)
|
|
|
|
dev_err(&client->adapter->dev, "i2c read failed\n");
|
|
|
|
else
|
|
|
|
memcpy(data, buffer, data_len);
|
|
|
|
|
|
|
|
kfree(buffer);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_gsb_i2c_write_bytes(struct i2c_client *client,
|
|
|
|
u8 cmd, u8 *data, u8 data_len)
|
|
|
|
{
|
|
|
|
|
|
|
|
struct i2c_msg msgs[1];
|
|
|
|
u8 *buffer;
|
|
|
|
int ret = AE_OK;
|
|
|
|
|
|
|
|
buffer = kzalloc(data_len + 1, GFP_KERNEL);
|
|
|
|
if (!buffer)
|
|
|
|
return AE_NO_MEMORY;
|
|
|
|
|
|
|
|
buffer[0] = cmd;
|
|
|
|
memcpy(buffer + 1, data, data_len);
|
|
|
|
|
|
|
|
msgs[0].addr = client->addr;
|
|
|
|
msgs[0].flags = client->flags;
|
|
|
|
msgs[0].len = data_len + 1;
|
|
|
|
msgs[0].buf = buffer;
|
|
|
|
|
|
|
|
ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
|
|
|
|
if (ret < 0)
|
|
|
|
dev_err(&client->adapter->dev, "i2c write failed\n");
|
|
|
|
|
|
|
|
kfree(buffer);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static acpi_status
|
|
|
|
acpi_i2c_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 acpi_i2c_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 = AE_OK;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
ret = acpi_buffer_to_resource(info->connection, info->length, &ares);
|
|
|
|
if (ACPI_FAILURE(ret))
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(&client, 0, sizeof(client));
|
|
|
|
client.adapter = adapter;
|
|
|
|
client.addr = sb->slave_address;
|
|
|
|
client.flags = 0;
|
|
|
|
|
|
|
|
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:
|
|
|
|
pr_info("protocol(0x%02x) is not supported.\n", accessor_type);
|
|
|
|
ret = AE_BAD_PARAMETER;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
gsb->status = status;
|
|
|
|
|
|
|
|
err:
|
|
|
|
ACPI_FREE(ares);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int acpi_i2c_install_space_handler(struct i2c_adapter *adapter)
|
|
|
|
{
|
2014-09-13 03:09:47 +08:00
|
|
|
acpi_handle handle;
|
2014-09-23 01:41:00 +08:00
|
|
|
struct acpi_i2c_handler_data *data;
|
|
|
|
acpi_status status;
|
|
|
|
|
2014-09-13 03:09:47 +08:00
|
|
|
if (!adapter->dev.parent)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
handle = ACPI_HANDLE(adapter->dev.parent);
|
|
|
|
|
2014-09-23 01:41:00 +08:00
|
|
|
if (!handle)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
data = kzalloc(sizeof(struct acpi_i2c_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,
|
|
|
|
&acpi_i2c_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;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void acpi_i2c_remove_space_handler(struct i2c_adapter *adapter)
|
|
|
|
{
|
2014-09-13 03:09:47 +08:00
|
|
|
acpi_handle handle;
|
2014-09-23 01:41:00 +08:00
|
|
|
struct acpi_i2c_handler_data *data;
|
|
|
|
acpi_status status;
|
|
|
|
|
2014-09-13 03:09:47 +08:00
|
|
|
if (!adapter->dev.parent)
|
|
|
|
return;
|
|
|
|
|
|
|
|
handle = ACPI_HANDLE(adapter->dev.parent);
|
|
|
|
|
2014-09-23 01:41:00 +08:00
|
|
|
if (!handle)
|
|
|
|
return;
|
|
|
|
|
|
|
|
acpi_remove_address_space_handler(handle,
|
|
|
|
ACPI_ADR_SPACE_GSBUS,
|
|
|
|
&acpi_i2c_space_handler);
|
|
|
|
|
|
|
|
status = acpi_bus_get_private_data(handle, (void **)&data);
|
|
|
|
if (ACPI_SUCCESS(status))
|
|
|
|
kfree(data);
|
|
|
|
|
|
|
|
acpi_bus_detach_private_data(handle);
|
|
|
|
}
|
|
|
|
#else /* CONFIG_ACPI_I2C_OPREGION */
|
|
|
|
static inline void acpi_i2c_remove_space_handler(struct i2c_adapter *adapter)
|
|
|
|
{ }
|
|
|
|
|
|
|
|
static inline int acpi_i2c_install_space_handler(struct i2c_adapter *adapter)
|
|
|
|
{ return 0; }
|
|
|
|
#endif /* CONFIG_ACPI_I2C_OPREGION */
|
|
|
|
|
2007-02-14 05:09:00 +08:00
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
|
2008-04-30 05:11:39 +08:00
|
|
|
static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
|
|
|
|
const struct i2c_client *client)
|
|
|
|
{
|
|
|
|
while (id->name[0]) {
|
|
|
|
if (strcmp(client->name, id->name) == 0)
|
|
|
|
return id;
|
|
|
|
id++;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
static int i2c_device_match(struct device *dev, struct device_driver *drv)
|
|
|
|
{
|
2009-09-19 04:45:45 +08:00
|
|
|
struct i2c_client *client = i2c_verify_client(dev);
|
|
|
|
struct i2c_driver *driver;
|
|
|
|
|
|
|
|
if (!client)
|
|
|
|
return 0;
|
2007-05-02 05:26:30 +08:00
|
|
|
|
2010-06-08 21:48:19 +08:00
|
|
|
/* Attempt an OF style match */
|
|
|
|
if (of_driver_match_device(dev, drv))
|
|
|
|
return 1;
|
|
|
|
|
2012-11-23 19:23:40 +08:00
|
|
|
/* Then ACPI style match */
|
|
|
|
if (acpi_driver_match_device(dev, drv))
|
|
|
|
return 1;
|
|
|
|
|
2009-09-19 04:45:45 +08:00
|
|
|
driver = to_i2c_driver(drv);
|
2008-04-30 05:11:39 +08:00
|
|
|
/* match on an id table if there is one */
|
|
|
|
if (driver->id_table)
|
|
|
|
return i2c_match_id(driver->id_table, client) != NULL;
|
|
|
|
|
2008-05-19 02:49:41 +08:00
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2007-05-02 05:26:30 +08:00
|
|
|
|
|
|
|
/* uevent helps with hotplug: modprobe -q $(MODALIAS) */
|
2007-08-14 21:15:12 +08:00
|
|
|
static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
|
2007-05-02 05:26:30 +08:00
|
|
|
{
|
|
|
|
struct i2c_client *client = to_i2c_client(dev);
|
ACPI: fix module autoloading for ACPI enumerated devices
ACPI enumerated devices has ACPI style _HID and _CID strings,
all of these strings can be used for both driver loading and matching.
Currently, in Platform, I2C and SPI bus, the ACPI style driver matching
is supported by invoking acpi_driver_match_device() in bus .match() callback.
But, the module autoloading is still broken.
For example, there is any ACPI device with _HID "INTABCD" that is
enumerated to platform bus, and we have a driver that can probe it.
The driver exports its module_alias as "acpi:INTABCD" use the following code
static const struct acpi_device_id xxx_acpi_match[] = {
{ "INTABCD", 0 },
{ }
};
MODULE_DEVICE_TABLE(acpi, xxx_acpi_match);
But, unfortunately, the device' modalias is shown as "platform:INTABCD:00",
please refer to modalias_show() and platform_uevent() in
drivers/base/platform.c.
This results in that the driver will not be loaded automatically when the
device node is created, because their modalias do not match.
This also applies to I2C and SPI bus.
With this patch, the device' modalias will be shown as "acpi:INTABCD" as well.
Signed-off-by: Zhang Rui <rui.zhang@intel.com>
Acked-by: Mark Brown <broonie@linaro.org>
Acked-by: Wolfram Sang <wsa@the-dreams.de>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-01-14 16:46:37 +08:00
|
|
|
int rc;
|
|
|
|
|
|
|
|
rc = acpi_device_uevent_modalias(dev, env);
|
|
|
|
if (rc != -ENODEV)
|
|
|
|
return rc;
|
2007-05-02 05:26:30 +08:00
|
|
|
|
2008-05-19 02:49:41 +08:00
|
|
|
if (add_uevent_var(env, "MODALIAS=%s%s",
|
|
|
|
I2C_MODULE_PREFIX, client->name))
|
|
|
|
return -ENOMEM;
|
2007-05-02 05:26:30 +08:00
|
|
|
dev_dbg(dev, "uevent\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-02-28 20:56:31 +08: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);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void set_scl_gpio_value(struct i2c_adapter *adap, int val)
|
|
|
|
{
|
|
|
|
gpio_set_value(adap->bus_recovery_info->scl_gpio, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int get_sda_gpio_value(struct i2c_adapter *adap)
|
|
|
|
{
|
|
|
|
return gpio_get_value(adap->bus_recovery_info->sda_gpio);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int i2c_get_gpios_for_recovery(struct i2c_adapter *adap)
|
|
|
|
{
|
|
|
|
struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
|
|
|
|
struct device *dev = &adap->dev;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
ret = gpio_request_one(bri->scl_gpio, GPIOF_OPEN_DRAIN |
|
|
|
|
GPIOF_OUT_INIT_HIGH, "i2c-scl");
|
|
|
|
if (ret) {
|
|
|
|
dev_warn(dev, "Can't get SCL gpio: %d\n", bri->scl_gpio);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bri->get_sda) {
|
|
|
|
if (gpio_request_one(bri->sda_gpio, GPIOF_IN, "i2c-sda")) {
|
|
|
|
/* work without SDA polling */
|
|
|
|
dev_warn(dev, "Can't get SDA gpio: %d. Not using SDA polling\n",
|
|
|
|
bri->sda_gpio);
|
|
|
|
bri->get_sda = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void i2c_put_gpios_for_recovery(struct i2c_adapter *adap)
|
|
|
|
{
|
|
|
|
struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
|
|
|
|
|
|
|
|
if (bri->get_sda)
|
|
|
|
gpio_free(bri->sda_gpio);
|
|
|
|
|
|
|
|
gpio_free(bri->scl_gpio);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We are generating clock pulses. ndelay() determines durating of clk pulses.
|
|
|
|
* We will generate clock with rate 100 KHz and so duration of both clock levels
|
|
|
|
* is: delay in ns = (10^6 / 100) / 2
|
|
|
|
*/
|
|
|
|
#define RECOVERY_NDELAY 5000
|
|
|
|
#define RECOVERY_CLK_CNT 9
|
|
|
|
|
|
|
|
static int i2c_generic_recovery(struct i2c_adapter *adap)
|
|
|
|
{
|
|
|
|
struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
|
|
|
|
int i = 0, val = 1, ret = 0;
|
|
|
|
|
|
|
|
if (bri->prepare_recovery)
|
|
|
|
bri->prepare_recovery(bri);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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(bri);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int i2c_generic_scl_recovery(struct i2c_adapter *adap)
|
|
|
|
{
|
|
|
|
adap->bus_recovery_info->set_scl(adap, 1);
|
|
|
|
return i2c_generic_recovery(adap);
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2007-02-14 05:09:00 +08:00
|
|
|
static int i2c_device_probe(struct device *dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-09-19 04:45:45 +08:00
|
|
|
struct i2c_client *client = i2c_verify_client(dev);
|
|
|
|
struct i2c_driver *driver;
|
2008-03-12 21:15:00 +08:00
|
|
|
int status;
|
2007-05-02 05:26:30 +08:00
|
|
|
|
2009-09-19 04:45:45 +08:00
|
|
|
if (!client)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
driver = to_i2c_driver(dev->driver);
|
2008-07-15 04:38:30 +08:00
|
|
|
if (!driver->probe || !driver->id_table)
|
2007-05-02 05:26:30 +08:00
|
|
|
return -ENODEV;
|
2013-09-29 16:51:06 +08:00
|
|
|
|
2008-08-28 14:33:22 +08:00
|
|
|
if (!device_can_wakeup(&client->dev))
|
|
|
|
device_init_wakeup(&client->dev,
|
|
|
|
client->flags & I2C_CLIENT_WAKE);
|
2007-05-02 05:26:30 +08:00
|
|
|
dev_dbg(dev, "probe\n");
|
2008-04-30 05:11:39 +08:00
|
|
|
|
2014-06-18 23:29:32 +08:00
|
|
|
status = of_clk_set_defaults(dev->of_node, false);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
|
2013-10-10 18:28:47 +08:00
|
|
|
acpi_dev_pm_attach(&client->dev, true);
|
2008-07-15 04:38:30 +08:00
|
|
|
status = driver->probe(client, i2c_match_id(driver->id_table, client));
|
2014-01-22 00:48:34 +08:00
|
|
|
if (status)
|
2013-10-10 18:28:47 +08:00
|
|
|
acpi_dev_pm_detach(&client->dev, true);
|
2014-01-22 00:48:34 +08:00
|
|
|
|
2008-03-12 21:15:00 +08:00
|
|
|
return status;
|
2007-02-14 05:09:00 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-02-14 05:09:00 +08:00
|
|
|
static int i2c_device_remove(struct device *dev)
|
|
|
|
{
|
2009-09-19 04:45:45 +08:00
|
|
|
struct i2c_client *client = i2c_verify_client(dev);
|
2007-05-02 05:26:30 +08:00
|
|
|
struct i2c_driver *driver;
|
2014-01-22 00:48:34 +08:00
|
|
|
int status = 0;
|
2007-05-02 05:26:30 +08:00
|
|
|
|
2009-09-19 04:45:45 +08:00
|
|
|
if (!client || !dev->driver)
|
2007-05-02 05:26:30 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
driver = to_i2c_driver(dev->driver);
|
|
|
|
if (driver->remove) {
|
|
|
|
dev_dbg(dev, "remove\n");
|
|
|
|
status = driver->remove(client);
|
|
|
|
}
|
2014-01-22 00:48:34 +08:00
|
|
|
|
2013-10-10 18:28:47 +08:00
|
|
|
acpi_dev_pm_detach(&client->dev, true);
|
2007-05-02 05:26:30 +08:00
|
|
|
return status;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2007-02-14 05:09:00 +08:00
|
|
|
static void i2c_device_shutdown(struct device *dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-09-19 04:45:45 +08:00
|
|
|
struct i2c_client *client = i2c_verify_client(dev);
|
2007-02-14 05:09:00 +08:00
|
|
|
struct i2c_driver *driver;
|
|
|
|
|
2009-09-19 04:45:45 +08:00
|
|
|
if (!client || !dev->driver)
|
2007-02-14 05:09:00 +08:00
|
|
|
return;
|
|
|
|
driver = to_i2c_driver(dev->driver);
|
|
|
|
if (driver->shutdown)
|
2009-09-19 04:45:45 +08:00
|
|
|
driver->shutdown(client);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2010-05-11 05:09:30 +08:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
|
|
static int i2c_legacy_suspend(struct device *dev, pm_message_t mesg)
|
2009-12-15 04:17:30 +08:00
|
|
|
{
|
2010-05-11 05:09:30 +08:00
|
|
|
struct i2c_client *client = i2c_verify_client(dev);
|
|
|
|
struct i2c_driver *driver;
|
2009-12-15 04:17:30 +08:00
|
|
|
|
2010-05-11 05:09:30 +08:00
|
|
|
if (!client || !dev->driver)
|
2009-12-15 04:17:30 +08:00
|
|
|
return 0;
|
2010-05-11 05:09:30 +08:00
|
|
|
driver = to_i2c_driver(dev->driver);
|
|
|
|
if (!driver->suspend)
|
2009-12-15 04:17:30 +08:00
|
|
|
return 0;
|
2010-05-11 05:09:30 +08:00
|
|
|
return driver->suspend(client, mesg);
|
2009-12-15 04:17:30 +08:00
|
|
|
}
|
|
|
|
|
2010-05-11 05:09:30 +08:00
|
|
|
static int i2c_legacy_resume(struct device *dev)
|
2009-12-15 04:17:30 +08:00
|
|
|
{
|
2010-05-11 05:09:30 +08:00
|
|
|
struct i2c_client *client = i2c_verify_client(dev);
|
|
|
|
struct i2c_driver *driver;
|
2009-12-15 04:17:30 +08:00
|
|
|
|
2010-05-11 05:09:30 +08:00
|
|
|
if (!client || !dev->driver)
|
2009-12-15 04:17:30 +08:00
|
|
|
return 0;
|
2010-05-11 05:09:30 +08:00
|
|
|
driver = to_i2c_driver(dev->driver);
|
|
|
|
if (!driver->resume)
|
2009-12-15 04:17:30 +08:00
|
|
|
return 0;
|
2010-05-11 05:09:30 +08:00
|
|
|
return driver->resume(client);
|
2009-12-15 04:17:30 +08:00
|
|
|
}
|
|
|
|
|
2010-05-11 05:09:30 +08:00
|
|
|
static int i2c_device_pm_suspend(struct device *dev)
|
2010-03-02 19:23:46 +08:00
|
|
|
{
|
2010-05-11 05:09:30 +08:00
|
|
|
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
|
2010-03-02 19:23:46 +08:00
|
|
|
|
2011-01-15 05:03:49 +08:00
|
|
|
if (pm)
|
|
|
|
return pm_generic_suspend(dev);
|
|
|
|
else
|
|
|
|
return i2c_legacy_suspend(dev, PMSG_SUSPEND);
|
2010-03-02 19:23:46 +08:00
|
|
|
}
|
|
|
|
|
2010-05-11 05:09:30 +08:00
|
|
|
static int i2c_device_pm_resume(struct device *dev)
|
2010-03-02 19:23:46 +08:00
|
|
|
{
|
2010-05-11 05:09:30 +08:00
|
|
|
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
|
2010-03-02 19:23:46 +08:00
|
|
|
|
2010-05-11 05:09:30 +08:00
|
|
|
if (pm)
|
2011-01-15 05:03:49 +08:00
|
|
|
return pm_generic_resume(dev);
|
2010-05-11 05:09:30 +08:00
|
|
|
else
|
2011-01-15 05:03:49 +08:00
|
|
|
return i2c_legacy_resume(dev);
|
2010-03-02 19:23:46 +08:00
|
|
|
}
|
|
|
|
|
2010-05-11 05:09:30 +08:00
|
|
|
static int i2c_device_pm_freeze(struct device *dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2010-05-11 05:09:30 +08:00
|
|
|
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
|
2007-02-14 05:09:00 +08:00
|
|
|
|
2011-01-15 05:03:49 +08:00
|
|
|
if (pm)
|
|
|
|
return pm_generic_freeze(dev);
|
|
|
|
else
|
|
|
|
return i2c_legacy_suspend(dev, PMSG_FREEZE);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2010-05-11 05:09:30 +08:00
|
|
|
static int i2c_device_pm_thaw(struct device *dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2010-05-11 05:09:30 +08:00
|
|
|
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
|
2007-02-14 05:09:00 +08:00
|
|
|
|
2011-01-15 05:03:49 +08:00
|
|
|
if (pm)
|
|
|
|
return pm_generic_thaw(dev);
|
|
|
|
else
|
|
|
|
return i2c_legacy_resume(dev);
|
2010-05-11 05:09:30 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int i2c_device_pm_poweroff(struct device *dev)
|
|
|
|
{
|
|
|
|
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
|
|
|
|
|
2011-01-15 05:03:49 +08:00
|
|
|
if (pm)
|
|
|
|
return pm_generic_poweroff(dev);
|
|
|
|
else
|
|
|
|
return i2c_legacy_suspend(dev, PMSG_HIBERNATE);
|
2010-05-11 05:09:30 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int i2c_device_pm_restore(struct device *dev)
|
|
|
|
{
|
|
|
|
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
|
|
|
|
|
|
|
|
if (pm)
|
2011-01-15 05:03:49 +08:00
|
|
|
return pm_generic_restore(dev);
|
2010-05-11 05:09:30 +08:00
|
|
|
else
|
2011-01-15 05:03:49 +08:00
|
|
|
return i2c_legacy_resume(dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2010-05-11 05:09:30 +08:00
|
|
|
#else /* !CONFIG_PM_SLEEP */
|
|
|
|
#define i2c_device_pm_suspend NULL
|
|
|
|
#define i2c_device_pm_resume NULL
|
|
|
|
#define i2c_device_pm_freeze NULL
|
|
|
|
#define i2c_device_pm_thaw NULL
|
|
|
|
#define i2c_device_pm_poweroff NULL
|
|
|
|
#define i2c_device_pm_restore NULL
|
|
|
|
#endif /* !CONFIG_PM_SLEEP */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-02 05:26:31 +08:00
|
|
|
static void i2c_client_dev_release(struct device *dev)
|
|
|
|
{
|
|
|
|
kfree(to_i2c_client(dev));
|
|
|
|
}
|
|
|
|
|
2009-03-29 04:34:46 +08:00
|
|
|
static ssize_t
|
2009-09-19 04:45:46 +08:00
|
|
|
show_name(struct device *dev, struct device_attribute *attr, char *buf)
|
2007-05-02 05:26:30 +08:00
|
|
|
{
|
2009-09-19 04:45:46 +08:00
|
|
|
return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
|
|
|
|
to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
|
2007-05-02 05:26:30 +08:00
|
|
|
}
|
|
|
|
|
2009-03-29 04:34:46 +08:00
|
|
|
static ssize_t
|
|
|
|
show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
|
2007-05-02 05:26:30 +08:00
|
|
|
{
|
|
|
|
struct i2c_client *client = to_i2c_client(dev);
|
ACPI: fix module autoloading for ACPI enumerated devices
ACPI enumerated devices has ACPI style _HID and _CID strings,
all of these strings can be used for both driver loading and matching.
Currently, in Platform, I2C and SPI bus, the ACPI style driver matching
is supported by invoking acpi_driver_match_device() in bus .match() callback.
But, the module autoloading is still broken.
For example, there is any ACPI device with _HID "INTABCD" that is
enumerated to platform bus, and we have a driver that can probe it.
The driver exports its module_alias as "acpi:INTABCD" use the following code
static const struct acpi_device_id xxx_acpi_match[] = {
{ "INTABCD", 0 },
{ }
};
MODULE_DEVICE_TABLE(acpi, xxx_acpi_match);
But, unfortunately, the device' modalias is shown as "platform:INTABCD:00",
please refer to modalias_show() and platform_uevent() in
drivers/base/platform.c.
This results in that the driver will not be loaded automatically when the
device node is created, because their modalias do not match.
This also applies to I2C and SPI bus.
With this patch, the device' modalias will be shown as "acpi:INTABCD" as well.
Signed-off-by: Zhang Rui <rui.zhang@intel.com>
Acked-by: Mark Brown <broonie@linaro.org>
Acked-by: Wolfram Sang <wsa@the-dreams.de>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-01-14 16:46:37 +08:00
|
|
|
int len;
|
|
|
|
|
|
|
|
len = acpi_device_modalias(dev, buf, PAGE_SIZE -1);
|
|
|
|
if (len != -ENODEV)
|
|
|
|
return len;
|
|
|
|
|
2008-05-19 02:49:41 +08:00
|
|
|
return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
|
2007-05-02 05:26:30 +08:00
|
|
|
}
|
|
|
|
|
2009-09-19 04:45:46 +08:00
|
|
|
static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
|
2009-09-19 04:45:45 +08:00
|
|
|
static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
|
|
|
|
|
|
|
|
static struct attribute *i2c_dev_attrs[] = {
|
|
|
|
&dev_attr_name.attr,
|
2007-05-02 05:26:30 +08:00
|
|
|
/* modalias helps coldplug: modprobe $(cat .../modalias) */
|
2009-09-19 04:45:45 +08:00
|
|
|
&dev_attr_modalias.attr,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct attribute_group i2c_dev_attr_group = {
|
|
|
|
.attrs = i2c_dev_attrs,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct attribute_group *i2c_dev_attr_groups[] = {
|
|
|
|
&i2c_dev_attr_group,
|
|
|
|
NULL
|
2007-05-02 05:26:30 +08:00
|
|
|
};
|
|
|
|
|
2010-01-17 03:43:12 +08:00
|
|
|
static const struct dev_pm_ops i2c_device_pm_ops = {
|
2009-12-15 04:17:30 +08:00
|
|
|
.suspend = i2c_device_pm_suspend,
|
|
|
|
.resume = i2c_device_pm_resume,
|
2010-05-11 05:09:30 +08:00
|
|
|
.freeze = i2c_device_pm_freeze,
|
|
|
|
.thaw = i2c_device_pm_thaw,
|
|
|
|
.poweroff = i2c_device_pm_poweroff,
|
|
|
|
.restore = i2c_device_pm_restore,
|
|
|
|
SET_RUNTIME_PM_OPS(
|
|
|
|
pm_generic_runtime_suspend,
|
|
|
|
pm_generic_runtime_resume,
|
PM / Runtime: Rework the "runtime idle" helper routine
The "runtime idle" helper routine, rpm_idle(), currently ignores
return values from .runtime_idle() callbacks executed by it.
However, it turns out that many subsystems use
pm_generic_runtime_idle() which checks the return value of the
driver's callback and executes pm_runtime_suspend() for the device
unless that value is not 0. If that logic is moved to rpm_idle()
instead, pm_generic_runtime_idle() can be dropped and its users
will not need any .runtime_idle() callbacks any more.
Moreover, the PCI, SCSI, and SATA subsystems' .runtime_idle()
routines, pci_pm_runtime_idle(), scsi_runtime_idle(), and
ata_port_runtime_idle(), respectively, as well as a few drivers'
ones may be simplified if rpm_idle() calls rpm_suspend() after 0 has
been returned by the .runtime_idle() callback executed by it.
To reduce overall code bloat, make the changes described above.
Tested-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Tested-by: Kevin Hilman <khilman@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Kevin Hilman <khilman@linaro.org>
Reviewed-by: Ulf Hansson <ulf.hansson@linaro.org>
Acked-by: Alan Stern <stern@rowland.harvard.edu>
2013-06-04 03:49:52 +08:00
|
|
|
NULL
|
2010-05-11 05:09:30 +08:00
|
|
|
)
|
2009-12-15 04:17:30 +08:00
|
|
|
};
|
|
|
|
|
2008-07-15 04:38:35 +08:00
|
|
|
struct bus_type i2c_bus_type = {
|
2007-02-14 05:09:00 +08:00
|
|
|
.name = "i2c",
|
|
|
|
.match = i2c_device_match,
|
|
|
|
.probe = i2c_device_probe,
|
|
|
|
.remove = i2c_device_remove,
|
|
|
|
.shutdown = i2c_device_shutdown,
|
2009-12-15 04:17:30 +08:00
|
|
|
.pm = &i2c_device_pm_ops,
|
2006-01-05 22:37:50 +08:00
|
|
|
};
|
2008-07-15 04:38:35 +08:00
|
|
|
EXPORT_SYMBOL_GPL(i2c_bus_type);
|
2006-01-05 22:37:50 +08:00
|
|
|
|
2009-09-19 04:45:45 +08:00
|
|
|
static struct device_type i2c_client_type = {
|
|
|
|
.groups = i2c_dev_attr_groups,
|
|
|
|
.uevent = i2c_device_uevent,
|
|
|
|
.release = i2c_client_dev_release,
|
|
|
|
};
|
|
|
|
|
2008-01-28 01:14:51 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2009-09-19 04:45:45 +08:00
|
|
|
return (dev->type == &i2c_client_type)
|
2008-01-28 01:14:51 +08:00
|
|
|
? to_i2c_client(dev)
|
|
|
|
: NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(i2c_verify_client);
|
|
|
|
|
|
|
|
|
2010-06-03 17:33:52 +08:00
|
|
|
/* This is a permissive address validity check, I2C address map constraints
|
2011-03-31 09:57:33 +08:00
|
|
|
* are purposely not enforced, except for the general call address. */
|
2010-06-03 17:33:52 +08:00
|
|
|
static int i2c_check_client_addr_validity(const struct i2c_client *client)
|
|
|
|
{
|
|
|
|
if (client->flags & I2C_CLIENT_TEN) {
|
|
|
|
/* 10-bit address, all values are valid */
|
|
|
|
if (client->addr > 0x3ff)
|
|
|
|
return -EINVAL;
|
|
|
|
} else {
|
|
|
|
/* 7-bit address, reject the general call address */
|
|
|
|
if (client->addr == 0x00 || client->addr > 0x7f)
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-06-03 17:33:53 +08: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_addr_validity(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;
|
|
|
|
}
|
|
|
|
|
2010-06-03 17:33:55 +08: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 && client->addr == addr)
|
|
|
|
return -EBUSY;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-08-12 00:21:02 +08:00
|
|
|
/* walk up mux tree */
|
|
|
|
static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
|
|
|
|
{
|
2010-10-25 00:16:57 +08:00
|
|
|
struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
|
2010-08-12 00:21:02 +08:00
|
|
|
int result;
|
|
|
|
|
|
|
|
result = device_for_each_child(&adapter->dev, &addr,
|
|
|
|
__i2c_check_addr_busy);
|
|
|
|
|
2010-10-25 00:16:57 +08:00
|
|
|
if (!result && parent)
|
|
|
|
result = i2c_check_mux_parents(parent, addr);
|
2010-08-12 00:21:02 +08:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* recurse down mux tree */
|
|
|
|
static int i2c_check_mux_children(struct device *dev, void *addrp)
|
|
|
|
{
|
|
|
|
int result;
|
|
|
|
|
|
|
|
if (dev->type == &i2c_adapter_type)
|
|
|
|
result = device_for_each_child(dev, addrp,
|
|
|
|
i2c_check_mux_children);
|
|
|
|
else
|
|
|
|
result = __i2c_check_addr_busy(dev, addrp);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2010-06-03 17:33:55 +08:00
|
|
|
static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
|
|
|
|
{
|
2010-10-25 00:16:57 +08:00
|
|
|
struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
|
2010-08-12 00:21:02 +08:00
|
|
|
int result = 0;
|
|
|
|
|
2010-10-25 00:16:57 +08:00
|
|
|
if (parent)
|
|
|
|
result = i2c_check_mux_parents(parent, addr);
|
2010-08-12 00:21:02 +08:00
|
|
|
|
|
|
|
if (!result)
|
|
|
|
result = device_for_each_child(&adapter->dev, &addr,
|
|
|
|
i2c_check_mux_children);
|
|
|
|
|
|
|
|
return result;
|
2010-06-03 17:33:55 +08:00
|
|
|
}
|
|
|
|
|
2010-08-12 00:20:58 +08:00
|
|
|
/**
|
|
|
|
* i2c_lock_adapter - Get exclusive access to an I2C bus segment
|
|
|
|
* @adapter: Target I2C bus segment
|
|
|
|
*/
|
|
|
|
void i2c_lock_adapter(struct i2c_adapter *adapter)
|
|
|
|
{
|
2010-10-25 00:16:57 +08:00
|
|
|
struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
|
|
|
|
|
|
|
|
if (parent)
|
|
|
|
i2c_lock_adapter(parent);
|
2010-08-12 00:21:02 +08:00
|
|
|
else
|
|
|
|
rt_mutex_lock(&adapter->bus_lock);
|
2010-08-12 00:20:58 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(i2c_lock_adapter);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* i2c_trylock_adapter - Try to get exclusive access to an I2C bus segment
|
|
|
|
* @adapter: Target I2C bus segment
|
|
|
|
*/
|
|
|
|
static int i2c_trylock_adapter(struct i2c_adapter *adapter)
|
|
|
|
{
|
2010-10-25 00:16:57 +08:00
|
|
|
struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
|
|
|
|
|
|
|
|
if (parent)
|
|
|
|
return i2c_trylock_adapter(parent);
|
2010-08-12 00:21:02 +08:00
|
|
|
else
|
|
|
|
return rt_mutex_trylock(&adapter->bus_lock);
|
2010-08-12 00:20:58 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* i2c_unlock_adapter - Release exclusive access to an I2C bus segment
|
|
|
|
* @adapter: Target I2C bus segment
|
|
|
|
*/
|
|
|
|
void i2c_unlock_adapter(struct i2c_adapter *adapter)
|
|
|
|
{
|
2010-10-25 00:16:57 +08:00
|
|
|
struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
|
|
|
|
|
|
|
|
if (parent)
|
|
|
|
i2c_unlock_adapter(parent);
|
2010-08-12 00:21:02 +08:00
|
|
|
else
|
|
|
|
rt_mutex_unlock(&adapter->bus_lock);
|
2010-08-12 00:20:58 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(i2c_unlock_adapter);
|
|
|
|
|
2013-11-14 20:03:52 +08: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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* For 10-bit clients, add an arbitrary offset to avoid collisions */
|
|
|
|
dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
|
|
|
|
client->addr | ((client->flags & I2C_CLIENT_TEN)
|
|
|
|
? 0xa000 : 0));
|
|
|
|
}
|
|
|
|
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-02 05:26:31 +08:00
|
|
|
/**
|
2009-06-19 22:58:18 +08:00
|
|
|
* i2c_new_device - instantiate an i2c device
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-02 05:26:31 +08:00
|
|
|
* @adap: the adapter managing the device
|
|
|
|
* @info: describes one I2C device; bus_num is ignored
|
2007-07-12 20:12:28 +08:00
|
|
|
* Context: can sleep
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-02 05:26:31 +08:00
|
|
|
*
|
2009-06-19 22:58:18 +08:00
|
|
|
* 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.
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-02 05:26:31 +08:00
|
|
|
*
|
|
|
|
* 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;
|
2007-10-14 05:56:29 +08:00
|
|
|
|
2008-10-23 02:21:33 +08:00
|
|
|
if (info->archdata)
|
|
|
|
client->dev.archdata = *info->archdata;
|
|
|
|
|
2008-08-28 14:33:22 +08:00
|
|
|
client->flags = info->flags;
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-02 05:26:31 +08:00
|
|
|
client->addr = info->addr;
|
|
|
|
client->irq = info->irq;
|
|
|
|
|
|
|
|
strlcpy(client->name, info->type, sizeof(client->name));
|
|
|
|
|
2010-06-03 17:33:52 +08:00
|
|
|
/* Check for address validity */
|
|
|
|
status = i2c_check_client_addr_validity(client);
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2009-06-19 22:58:18 +08:00
|
|
|
/* Check for address business */
|
2010-06-03 17:33:55 +08:00
|
|
|
status = i2c_check_addr_busy(adap, client->addr);
|
2009-06-19 22:58:18 +08:00
|
|
|
if (status)
|
|
|
|
goto out_err;
|
|
|
|
|
|
|
|
client->dev.parent = &client->adapter->dev;
|
|
|
|
client->dev.bus = &i2c_bus_type;
|
2009-09-19 04:45:45 +08:00
|
|
|
client->dev.type = &i2c_client_type;
|
2010-04-14 07:12:28 +08:00
|
|
|
client->dev.of_node = info->of_node;
|
ACPI / driver core: Store an ACPI device pointer in struct acpi_dev_node
Modify struct acpi_dev_node to contain a pointer to struct acpi_device
associated with the given device object (that is, its ACPI companion
device) instead of an ACPI handle corresponding to it. Introduce two
new macros for manipulating that pointer in a CONFIG_ACPI-safe way,
ACPI_COMPANION() and ACPI_COMPANION_SET(), and rework the
ACPI_HANDLE() macro to take the above changes into account.
Drop the ACPI_HANDLE_SET() macro entirely and rework its users to
use ACPI_COMPANION_SET() instead. For some of them who used to
pass the result of acpi_get_child() directly to ACPI_HANDLE_SET()
introduce a helper routine acpi_preset_companion() doing an
equivalent thing.
The main motivation for doing this is that there are things
represented by struct acpi_device objects that don't have valid
ACPI handles (so called fixed ACPI hardware features, such as
power and sleep buttons) and we would like to create platform
device objects for them and "glue" them to their ACPI companions
in the usual way (which currently is impossible due to the
lack of valid ACPI handles). However, there are more reasons
why it may be useful.
First, struct acpi_device pointers allow of much better type checking
than void pointers which are ACPI handles, so it should be more
difficult to write buggy code using modified struct acpi_dev_node
and the new macros. Second, the change should help to reduce (over
time) the number of places in which the result of ACPI_HANDLE() is
passed to acpi_bus_get_device() in order to obtain a pointer to the
struct acpi_device associated with the given "physical" device,
because now that pointer is returned by ACPI_COMPANION() directly.
Finally, the change should make it easier to write generic code that
will build both for CONFIG_ACPI set and unset without adding explicit
compiler directives to it.
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Tested-by: Mika Westerberg <mika.westerberg@linux.intel.com> # on Haswell
Reviewed-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Reviewed-by: Aaron Lu <aaron.lu@intel.com> # for ATA and SDIO part
2013-11-12 05:41:56 +08:00
|
|
|
ACPI_COMPANION_SET(&client->dev, info->acpi_node.companion);
|
2009-06-19 22:58:18 +08:00
|
|
|
|
2013-11-14 20:03:52 +08:00
|
|
|
i2c_dev_set_name(adap, client);
|
2009-06-19 22:58:18 +08:00
|
|
|
status = device_register(&client->dev);
|
|
|
|
if (status)
|
|
|
|
goto out_err;
|
|
|
|
|
|
|
|
dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
|
|
|
|
client->name, dev_name(&client->dev));
|
|
|
|
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-02 05:26:31 +08:00
|
|
|
return client;
|
2009-06-19 22:58:18 +08:00
|
|
|
|
|
|
|
out_err:
|
|
|
|
dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
|
|
|
|
"(%d)\n", client->name, client->addr, status);
|
2010-06-03 17:33:52 +08:00
|
|
|
out_err_silent:
|
2009-06-19 22:58:18 +08:00
|
|
|
kfree(client);
|
|
|
|
return NULL;
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-02 05:26:31 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(i2c_new_device);
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* i2c_unregister_device - reverse effect of i2c_new_device()
|
|
|
|
* @client: value returned from i2c_new_device()
|
2007-07-12 20:12:28 +08:00
|
|
|
* Context: can sleep
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-02 05:26:31 +08:00
|
|
|
*/
|
|
|
|
void i2c_unregister_device(struct i2c_client *client)
|
2007-05-02 05:26:30 +08:00
|
|
|
{
|
|
|
|
device_unregister(&client->dev);
|
|
|
|
}
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-02 05:26:31 +08:00
|
|
|
EXPORT_SYMBOL_GPL(i2c_unregister_device);
|
2007-05-02 05:26:30 +08:00
|
|
|
|
|
|
|
|
2008-05-12 02:37:06 +08:00
|
|
|
static const struct i2c_device_id dummy_id[] = {
|
|
|
|
{ "dummy", 0 },
|
|
|
|
{ },
|
|
|
|
};
|
|
|
|
|
2008-04-30 05:11:39 +08:00
|
|
|
static int dummy_probe(struct i2c_client *client,
|
|
|
|
const struct i2c_device_id *id)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dummy_remove(struct i2c_client *client)
|
2008-01-28 01:14:52 +08:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct i2c_driver dummy_driver = {
|
|
|
|
.driver.name = "dummy",
|
2008-04-30 05:11:39 +08:00
|
|
|
.probe = dummy_probe,
|
|
|
|
.remove = dummy_remove,
|
2008-05-12 02:37:06 +08:00
|
|
|
.id_table = dummy_id,
|
2008-01-28 01:14:52 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2009-03-29 04:34:46 +08:00
|
|
|
struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
|
2008-01-28 01:14:52 +08:00
|
|
|
{
|
|
|
|
struct i2c_board_info info = {
|
2008-05-12 02:37:06 +08:00
|
|
|
I2C_BOARD_INFO("dummy", address),
|
2008-01-28 01:14:52 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
return i2c_new_device(adapter, &info);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(i2c_new_dummy);
|
|
|
|
|
2007-02-14 05:09:00 +08:00
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
|
2007-05-02 05:26:28 +08:00
|
|
|
/* I2C bus adapters -- one roots each I2C or SMBUS segment */
|
|
|
|
|
2007-10-14 05:56:30 +08:00
|
|
|
static void i2c_adapter_dev_release(struct device *dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2007-05-02 05:26:28 +08:00
|
|
|
struct i2c_adapter *adap = to_i2c_adapter(dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
complete(&adap->dev_released);
|
|
|
|
}
|
|
|
|
|
2012-09-10 16:14:02 +08:00
|
|
|
/*
|
|
|
|
* This function is only needed for mutex_lock_nested, so it is never
|
|
|
|
* called unless locking correctness checking is enabled. Thus we
|
|
|
|
* make it inline to avoid a compiler warning. That's what gcc ends up
|
|
|
|
* doing anyway.
|
|
|
|
*/
|
|
|
|
static inline unsigned int i2c_adapter_depth(struct i2c_adapter *adapter)
|
|
|
|
{
|
|
|
|
unsigned int depth = 0;
|
|
|
|
|
|
|
|
while ((adapter = i2c_parent_is_i2c_adapter(adapter)))
|
|
|
|
depth++;
|
|
|
|
|
|
|
|
return depth;
|
|
|
|
}
|
|
|
|
|
2009-06-19 22:58:20 +08:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
client = i2c_new_device(adap, &info);
|
|
|
|
if (!client)
|
2010-06-03 17:33:52 +08:00
|
|
|
return -EINVAL;
|
2009-06-19 22:58:20 +08:00
|
|
|
|
|
|
|
/* Keep track of the added device */
|
2010-08-12 00:21:01 +08:00
|
|
|
mutex_lock(&adap->userspace_clients_lock);
|
2010-05-04 17:09:28 +08:00
|
|
|
list_add_tail(&client->detected, &adap->userspace_clients);
|
2010-08-12 00:21:01 +08:00
|
|
|
mutex_unlock(&adap->userspace_clients_lock);
|
2009-06-19 22:58:20 +08:00
|
|
|
dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
|
|
|
|
info.type, info.addr);
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
2012-09-10 16:14:02 +08:00
|
|
|
mutex_lock_nested(&adap->userspace_clients_lock,
|
|
|
|
i2c_adapter_depth(adap));
|
2010-05-04 17:09:28 +08:00
|
|
|
list_for_each_entry_safe(client, next, &adap->userspace_clients,
|
|
|
|
detected) {
|
|
|
|
if (client->addr == addr) {
|
2009-06-19 22:58:20 +08:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
2010-08-12 00:21:01 +08:00
|
|
|
mutex_unlock(&adap->userspace_clients_lock);
|
2009-06-19 22:58:20 +08:00
|
|
|
|
|
|
|
if (res < 0)
|
|
|
|
dev_err(dev, "%s: Can't find device in list\n",
|
|
|
|
"delete_device");
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2009-09-19 04:45:46 +08:00
|
|
|
static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
|
2013-05-17 20:56:35 +08:00
|
|
|
static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device, S_IWUSR, NULL,
|
|
|
|
i2c_sysfs_delete_device);
|
2009-09-19 04:45:46 +08:00
|
|
|
|
|
|
|
static struct attribute *i2c_adapter_attrs[] = {
|
|
|
|
&dev_attr_name.attr,
|
|
|
|
&dev_attr_new_device.attr,
|
|
|
|
&dev_attr_delete_device.attr,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct attribute_group i2c_adapter_attr_group = {
|
|
|
|
.attrs = i2c_adapter_attrs,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct attribute_group *i2c_adapter_attr_groups[] = {
|
|
|
|
&i2c_adapter_attr_group,
|
|
|
|
NULL
|
2007-05-02 05:26:28 +08:00
|
|
|
};
|
2007-01-04 20:07:04 +08:00
|
|
|
|
2010-08-12 00:21:02 +08:00
|
|
|
struct device_type i2c_adapter_type = {
|
2009-09-19 04:45:46 +08:00
|
|
|
.groups = i2c_adapter_attr_groups,
|
|
|
|
.release = i2c_adapter_dev_release,
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
2010-08-12 00:21:02 +08:00
|
|
|
EXPORT_SYMBOL_GPL(i2c_adapter_type);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-04-18 02:43:33 +08:00
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(i2c_verify_adapter);
|
|
|
|
|
2009-09-19 04:45:46 +08:00
|
|
|
#ifdef CONFIG_I2C_COMPAT
|
|
|
|
static struct class_compat *i2c_adapter_compat_class;
|
|
|
|
#endif
|
|
|
|
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-02 05:26:31 +08:00
|
|
|
static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
|
|
|
|
{
|
|
|
|
struct i2c_devinfo *devinfo;
|
|
|
|
|
2009-06-19 22:58:20 +08:00
|
|
|
down_read(&__i2c_board_lock);
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-02 05:26:31 +08:00
|
|
|
list_for_each_entry(devinfo, &__i2c_board_list, list) {
|
|
|
|
if (devinfo->busnum == adapter->nr
|
|
|
|
&& !i2c_new_device(adapter,
|
|
|
|
&devinfo->board_info))
|
2009-03-29 04:34:46 +08:00
|
|
|
dev_err(&adapter->dev,
|
|
|
|
"Can't create device at 0x%02x\n",
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-02 05:26:31 +08:00
|
|
|
devinfo->board_info.addr);
|
|
|
|
}
|
2009-06-19 22:58:20 +08:00
|
|
|
up_read(&__i2c_board_lock);
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-02 05:26:31 +08:00
|
|
|
}
|
|
|
|
|
2013-07-11 19:56:15 +08:00
|
|
|
/* OF support code */
|
|
|
|
|
|
|
|
#if IS_ENABLED(CONFIG_OF)
|
|
|
|
static void of_i2c_register_devices(struct i2c_adapter *adap)
|
|
|
|
{
|
|
|
|
void *result;
|
|
|
|
struct device_node *node;
|
|
|
|
|
|
|
|
/* 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");
|
|
|
|
|
|
|
|
for_each_available_child_of_node(adap->dev.of_node, node) {
|
|
|
|
struct i2c_board_info info = {};
|
|
|
|
struct dev_archdata dev_ad = {};
|
|
|
|
const __be32 *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);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
addr = of_get_property(node, "reg", &len);
|
|
|
|
if (!addr || (len < sizeof(int))) {
|
|
|
|
dev_err(&adap->dev, "of_i2c: invalid reg on %s\n",
|
|
|
|
node->full_name);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
info.addr = be32_to_cpup(addr);
|
|
|
|
if (info.addr > (1 << 10) - 1) {
|
|
|
|
dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s\n",
|
|
|
|
info.addr, node->full_name);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
info.irq = irq_of_parse_and_map(node, 0);
|
|
|
|
info.of_node = of_node_get(node);
|
|
|
|
info.archdata = &dev_ad;
|
|
|
|
|
|
|
|
if (of_get_property(node, "wakeup-source", NULL))
|
|
|
|
info.flags |= I2C_CLIENT_WAKE;
|
|
|
|
|
|
|
|
request_module("%s%s", I2C_MODULE_PREFIX, info.type);
|
|
|
|
|
|
|
|
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);
|
|
|
|
irq_dispose_mapping(info.irq);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int of_dev_node_match(struct device *dev, void *data)
|
|
|
|
{
|
|
|
|
return dev->of_node == data;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
|
|
|
dev = bus_find_device(&i2c_bus_type, NULL, node,
|
|
|
|
of_dev_node_match);
|
|
|
|
if (!dev)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return i2c_verify_client(dev);
|
|
|
|
}
|
|
|
|
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;
|
|
|
|
|
|
|
|
dev = bus_find_device(&i2c_bus_type, NULL, node,
|
|
|
|
of_dev_node_match);
|
|
|
|
if (!dev)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return i2c_verify_adapter(dev);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_find_i2c_adapter_by_node);
|
|
|
|
#else
|
|
|
|
static void of_i2c_register_devices(struct i2c_adapter *adap) { }
|
|
|
|
#endif /* CONFIG_OF */
|
|
|
|
|
2009-12-07 00:06:27 +08:00
|
|
|
static int i2c_do_add_adapter(struct i2c_driver *driver,
|
|
|
|
struct i2c_adapter *adap)
|
2008-01-28 01:14:49 +08:00
|
|
|
{
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-15 04:38:36 +08:00
|
|
|
/* Detect supported devices on that bus, and instantiate them */
|
|
|
|
i2c_detect(adap, driver);
|
|
|
|
|
|
|
|
/* Let legacy drivers scan this bus for matching devices */
|
2008-01-28 01:14:49 +08:00
|
|
|
if (driver->attach_adapter) {
|
2011-04-17 16:20:19 +08:00
|
|
|
dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
|
|
|
|
driver->driver.name);
|
2011-03-20 21:50:53 +08:00
|
|
|
dev_warn(&adap->dev, "Please use another way to instantiate "
|
|
|
|
"your i2c_client\n");
|
2008-01-28 01:14:49 +08:00
|
|
|
/* We ignore the return code; if it fails, too bad */
|
|
|
|
driver->attach_adapter(adap);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-12-07 00:06:27 +08:00
|
|
|
static int __process_new_adapter(struct device_driver *d, void *data)
|
|
|
|
{
|
|
|
|
return i2c_do_add_adapter(to_i2c_driver(d), data);
|
|
|
|
}
|
|
|
|
|
2007-05-02 05:26:31 +08:00
|
|
|
static int i2c_register_adapter(struct i2c_adapter *adap)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2010-08-12 00:20:59 +08:00
|
|
|
int res = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-10-14 23:30:05 +08:00
|
|
|
/* Can't register until after driver model init */
|
2009-06-19 22:58:19 +08:00
|
|
|
if (unlikely(WARN_ON(!i2c_bus_type.p))) {
|
|
|
|
res = -EAGAIN;
|
|
|
|
goto out_list;
|
|
|
|
}
|
2008-10-14 23:30:05 +08:00
|
|
|
|
2010-11-16 05:40:38 +08:00
|
|
|
/* Sanity checks */
|
|
|
|
if (unlikely(adap->name[0] == '\0')) {
|
|
|
|
pr_err("i2c-core: Attempt to register an adapter with "
|
|
|
|
"no name!\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
if (unlikely(!adap->algo)) {
|
|
|
|
pr_err("i2c-core: Attempt to register adapter '%s' with "
|
|
|
|
"no algo!\n", adap->name);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2009-12-07 00:06:22 +08:00
|
|
|
rt_mutex_init(&adap->bus_lock);
|
2010-08-12 00:21:01 +08:00
|
|
|
mutex_init(&adap->userspace_clients_lock);
|
2010-05-04 17:09:28 +08:00
|
|
|
INIT_LIST_HEAD(&adap->userspace_clients);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-03-29 04:34:43 +08:00
|
|
|
/* Set default timeout to 1 second if not already set */
|
|
|
|
if (adap->timeout == 0)
|
|
|
|
adap->timeout = HZ;
|
|
|
|
|
i2c: Replace bus_id with dev_name(), dev_set_name()
This patch is part of a larger patch series which will remove
the "char bus_id[20]" name string from struct device. The device
name is managed in the kobject anyway, and without any size
limitation, and just needlessly copied into "struct device".
To set and read the device name dev_name(dev) and dev_set_name(dev)
must be used. If your code uses static kobjects, which it shouldn't
do, "const char *init_name" can be used to statically provide the
name the registered device should have. At registration time, the
init_name field is cleared, to enforce the use of dev_name(dev) to
access the device name at a later time.
We need to get rid of all occurrences of bus_id in the entire tree
to be able to enable the new interface. Please apply this patch,
and possibly convert any remaining remaining occurrences of bus_id.
We want to submit a patch to -next, which will remove bus_id from
"struct device", to find the remaining pieces to convert, and finally
switch over to the new api, which will remove the 20 bytes array
and does no longer have a size limitation.
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Signed-off-by: Kay Sievers <kay.sievers@vrfy.org>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2009-01-07 21:29:16 +08:00
|
|
|
dev_set_name(&adap->dev, "i2c-%d", adap->nr);
|
2009-09-19 04:45:46 +08:00
|
|
|
adap->dev.bus = &i2c_bus_type;
|
|
|
|
adap->dev.type = &i2c_adapter_type;
|
2006-08-16 00:26:30 +08:00
|
|
|
res = device_register(&adap->dev);
|
|
|
|
if (res)
|
|
|
|
goto out_list;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-08-01 01:02:53 +08:00
|
|
|
dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
|
|
|
|
|
2009-09-19 04:45:46 +08:00
|
|
|
#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
|
|
|
|
|
2012-02-28 20:56:31 +08:00
|
|
|
/* bus recovery specific initialization */
|
|
|
|
if (adap->bus_recovery_info) {
|
|
|
|
struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
|
|
|
|
|
|
|
|
if (!bri->recover_bus) {
|
|
|
|
dev_err(&adap->dev, "No recover_bus() found, not using recovery\n");
|
|
|
|
adap->bus_recovery_info = NULL;
|
|
|
|
goto exit_recovery;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Generic GPIO recovery */
|
|
|
|
if (bri->recover_bus == i2c_generic_gpio_recovery) {
|
|
|
|
if (!gpio_is_valid(bri->scl_gpio)) {
|
|
|
|
dev_err(&adap->dev, "Invalid SCL gpio, not using recovery\n");
|
|
|
|
adap->bus_recovery_info = NULL;
|
|
|
|
goto exit_recovery;
|
|
|
|
}
|
|
|
|
|
|
|
|
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->set_scl || !bri->get_scl) {
|
|
|
|
/* Generic SCL recovery */
|
|
|
|
dev_err(&adap->dev, "No {get|set}_gpio() found, not using recovery\n");
|
|
|
|
adap->bus_recovery_info = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
exit_recovery:
|
2009-06-19 22:58:18 +08:00
|
|
|
/* create pre-declared device nodes */
|
2013-07-11 19:56:15 +08:00
|
|
|
of_i2c_register_devices(adap);
|
2013-08-21 22:28:23 +08:00
|
|
|
acpi_i2c_register_devices(adap);
|
I2C/ACPI: Add i2c ACPI operation region support
ACPI 5.0 spec(5.5.2.4.5) defines GenericSerialBus(i2c, spi, uart) operation region.
It allows ACPI aml code able to access such kind of devices to implement
some ACPI standard method.
ACPI Spec defines some access attribute to associate with i2c protocol.
AttribQuick Read/Write Quick Protocol
AttribSendReceive Send/Receive Byte Protocol
AttribByte Read/Write Byte Protocol
AttribWord Read/Write Word Protocol
AttribBlock Read/Write Block Protocol
AttribBytes Read/Write N-Bytes Protocol
AttribProcessCall Process Call Protocol
AttribBlockProcessCall Write Block-Read Block Process Call Protocol
AttribRawBytes Raw Read/Write N-BytesProtocol
AttribRawProcessBytes Raw Process Call Protocol
On the Asus T100TA, Bios use GenericSerialBus operation region to access
i2c device to get battery info.
Sample code From Asus T100TA
Scope (_SB.I2C1)
{
Name (UMPC, ResourceTemplate ()
{
I2cSerialBus (0x0066, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.I2C1",
0x00, ResourceConsumer, ,
)
})
...
OperationRegion (DVUM, GenericSerialBus, Zero, 0x0100)
Field (DVUM, BufferAcc, NoLock, Preserve)
{
Connection (UMPC),
Offset (0x81),
AccessAs (BufferAcc, AttribBytes (0x3E)),
FGC0, 8
}
...
}
Device (BATC)
{
Name (_HID, EisaId ("PNP0C0A")) // _HID: Hardware ID
Name (_UID, One) // _UID: Unique ID
...
Method (_BST, 0, NotSerialized) // _BST: Battery Status
{
If (LEqual (AVBL, One))
{
Store (FGC0, BFFG)
If (LNotEqual (STAT, One))
{
ShiftRight (CHST, 0x04, Local0)
And (Local0, 0x03, Local0)
If (LOr (LEqual (Local0, One), LEqual (Local0, 0x02)))
{
Store (0x02, Local1)
}
...
}
The i2c operation region is defined under I2C1 scope. _BST method under
battery device BATC read battery status from the field "FCG0". The request
would be sent to i2c operation region handler.
This patch is to add i2c ACPI operation region support. Due to there are
only "Byte" and "Bytes" protocol access on the Asus T100TA, other protocols
have not been tested.
About RawBytes and RawProcessBytes protocol, they needs specific drivers to interpret
reference data from AML code according ACPI 5.0 SPEC(5.5.2.4.5.3.9 and 5.5.2.4.5.3.10).
So far, not found such case and will add when find real case.
Signed-off-by: Lan Tianyu <tianyu.lan@intel.com>
Reviewed-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Signed-off-by: Wolfram Sang <wsa@the-dreams.de>
2014-05-20 20:59:23 +08:00
|
|
|
acpi_i2c_install_space_handler(adap);
|
2013-07-11 19:56:15 +08:00
|
|
|
|
2007-05-02 05:26:31 +08:00
|
|
|
if (adap->nr < __i2c_first_dynamic_bus_num)
|
|
|
|
i2c_scan_static_board_info(adap);
|
|
|
|
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-15 04:38:36 +08:00
|
|
|
/* Notify drivers */
|
2009-06-19 22:58:19 +08:00
|
|
|
mutex_lock(&core_lock);
|
2010-08-12 00:20:59 +08:00
|
|
|
bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
|
2008-01-28 01:14:49 +08:00
|
|
|
mutex_unlock(&core_lock);
|
2009-06-19 22:58:19 +08:00
|
|
|
|
|
|
|
return 0;
|
2006-08-16 00:26:30 +08:00
|
|
|
|
|
|
|
out_list:
|
2009-06-19 22:58:19 +08:00
|
|
|
mutex_lock(&core_lock);
|
2006-08-16 00:26:30 +08:00
|
|
|
idr_remove(&i2c_adapter_idr, adap->nr);
|
2009-06-19 22:58:19 +08:00
|
|
|
mutex_unlock(&core_lock);
|
|
|
|
return res;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2013-03-02 00:57:31 +08: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 (id < 0)
|
|
|
|
return id == -ENOSPC ? -EBUSY : id;
|
|
|
|
|
|
|
|
return i2c_register_adapter(adap);
|
|
|
|
}
|
|
|
|
|
2007-05-02 05:26:31 +08:00
|
|
|
/**
|
|
|
|
* i2c_add_adapter - declare i2c adapter, use dynamic bus number
|
|
|
|
* @adapter: the adapter to add
|
2007-07-12 20:12:28 +08:00
|
|
|
* Context: can sleep
|
2007-05-02 05:26:31 +08:00
|
|
|
*
|
|
|
|
* This routine is used to declare an I2C adapter when its bus number
|
2013-03-02 00:57:31 +08:00
|
|
|
* 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.
|
2007-05-02 05:26:31 +08:00
|
|
|
*
|
|
|
|
* 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)
|
|
|
|
{
|
2013-03-02 00:57:31 +08:00
|
|
|
struct device *dev = &adapter->dev;
|
2013-02-28 09:04:15 +08:00
|
|
|
int id;
|
2007-05-02 05:26:31 +08:00
|
|
|
|
2013-03-02 00:57:31 +08:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-01-28 01:14:49 +08:00
|
|
|
mutex_lock(&core_lock);
|
2013-02-28 09:04:15 +08:00
|
|
|
id = idr_alloc(&i2c_adapter_idr, adapter,
|
|
|
|
__i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
|
2008-01-28 01:14:49 +08:00
|
|
|
mutex_unlock(&core_lock);
|
2013-02-28 09:04:15 +08:00
|
|
|
if (id < 0)
|
|
|
|
return id;
|
2007-05-02 05:26:31 +08:00
|
|
|
|
|
|
|
adapter->nr = id;
|
2013-02-28 09:04:15 +08:00
|
|
|
|
2007-05-02 05:26:31 +08:00
|
|
|
return i2c_register_adapter(adapter);
|
|
|
|
}
|
|
|
|
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)
|
2007-07-12 20:12:28 +08:00
|
|
|
* Context: can sleep
|
2007-05-02 05:26:31 +08:00
|
|
|
*
|
|
|
|
* This routine is used to declare an I2C adapter when its bus number
|
2008-03-24 03:28:20 +08:00
|
|
|
* 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
|
2007-05-02 05:26:31 +08:00
|
|
|
* is used to properly configure I2C devices.
|
|
|
|
*
|
2011-07-25 23:49:43 +08:00
|
|
|
* 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.
|
|
|
|
*
|
2007-05-02 05:26:31 +08:00
|
|
|
* 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)
|
|
|
|
{
|
2011-07-25 23:49:43 +08:00
|
|
|
if (adap->nr == -1) /* -1 means dynamically assign bus id */
|
|
|
|
return i2c_add_adapter(adap);
|
2007-05-02 05:26:31 +08:00
|
|
|
|
2013-03-02 00:57:31 +08:00
|
|
|
return __i2c_add_numbered_adapter(adap);
|
2007-05-02 05:26:31 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
|
|
|
|
|
2013-03-09 16:16:44 +08:00
|
|
|
static void i2c_do_del_adapter(struct i2c_driver *driver,
|
2009-12-07 00:06:27 +08:00
|
|
|
struct i2c_adapter *adapter)
|
2008-01-28 01:14:49 +08:00
|
|
|
{
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-15 04:38:36 +08:00
|
|
|
struct i2c_client *client, *_n;
|
2008-01-28 01:14:49 +08:00
|
|
|
|
2009-03-29 04:34:40 +08:00
|
|
|
/* Remove the devices we created ourselves as the result of hardware
|
|
|
|
* probing (using a driver's detect method) */
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-15 04:38:36 +08:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
2008-01-28 01:14:49 +08:00
|
|
|
}
|
|
|
|
|
2009-06-19 22:58:19 +08:00
|
|
|
static int __unregister_client(struct device *dev, void *dummy)
|
2011-01-15 05:03:49 +08:00
|
|
|
{
|
|
|
|
struct i2c_client *client = i2c_verify_client(dev);
|
|
|
|
if (client && strcmp(client->name, "dummy"))
|
|
|
|
i2c_unregister_device(client);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __unregister_dummy(struct device *dev, void *dummy)
|
2009-06-19 22:58:19 +08:00
|
|
|
{
|
|
|
|
struct i2c_client *client = i2c_verify_client(dev);
|
|
|
|
if (client)
|
|
|
|
i2c_unregister_device(client);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-12-07 00:06:27 +08:00
|
|
|
static int __process_removed_adapter(struct device_driver *d, void *data)
|
|
|
|
{
|
2013-03-09 16:16:44 +08:00
|
|
|
i2c_do_del_adapter(to_i2c_driver(d), data);
|
|
|
|
return 0;
|
2009-12-07 00:06:27 +08:00
|
|
|
}
|
|
|
|
|
2007-07-12 20:12:28 +08: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.
|
|
|
|
*/
|
2013-03-09 16:16:47 +08:00
|
|
|
void i2c_del_adapter(struct i2c_adapter *adap)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-06-19 22:58:19 +08:00
|
|
|
struct i2c_adapter *found;
|
2009-11-26 16:22:33 +08:00
|
|
|
struct i2c_client *client, *next;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* First make sure that this adapter was ever added */
|
2009-06-19 22:58:19 +08:00
|
|
|
mutex_lock(&core_lock);
|
|
|
|
found = idr_find(&i2c_adapter_idr, adap->nr);
|
|
|
|
mutex_unlock(&core_lock);
|
|
|
|
if (found != adap) {
|
2005-08-01 01:02:53 +08:00
|
|
|
pr_debug("i2c-core: attempting to delete unregistered "
|
|
|
|
"adapter [%s]\n", adap->name);
|
2013-03-09 16:16:47 +08:00
|
|
|
return;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
I2C/ACPI: Add i2c ACPI operation region support
ACPI 5.0 spec(5.5.2.4.5) defines GenericSerialBus(i2c, spi, uart) operation region.
It allows ACPI aml code able to access such kind of devices to implement
some ACPI standard method.
ACPI Spec defines some access attribute to associate with i2c protocol.
AttribQuick Read/Write Quick Protocol
AttribSendReceive Send/Receive Byte Protocol
AttribByte Read/Write Byte Protocol
AttribWord Read/Write Word Protocol
AttribBlock Read/Write Block Protocol
AttribBytes Read/Write N-Bytes Protocol
AttribProcessCall Process Call Protocol
AttribBlockProcessCall Write Block-Read Block Process Call Protocol
AttribRawBytes Raw Read/Write N-BytesProtocol
AttribRawProcessBytes Raw Process Call Protocol
On the Asus T100TA, Bios use GenericSerialBus operation region to access
i2c device to get battery info.
Sample code From Asus T100TA
Scope (_SB.I2C1)
{
Name (UMPC, ResourceTemplate ()
{
I2cSerialBus (0x0066, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.I2C1",
0x00, ResourceConsumer, ,
)
})
...
OperationRegion (DVUM, GenericSerialBus, Zero, 0x0100)
Field (DVUM, BufferAcc, NoLock, Preserve)
{
Connection (UMPC),
Offset (0x81),
AccessAs (BufferAcc, AttribBytes (0x3E)),
FGC0, 8
}
...
}
Device (BATC)
{
Name (_HID, EisaId ("PNP0C0A")) // _HID: Hardware ID
Name (_UID, One) // _UID: Unique ID
...
Method (_BST, 0, NotSerialized) // _BST: Battery Status
{
If (LEqual (AVBL, One))
{
Store (FGC0, BFFG)
If (LNotEqual (STAT, One))
{
ShiftRight (CHST, 0x04, Local0)
And (Local0, 0x03, Local0)
If (LOr (LEqual (Local0, One), LEqual (Local0, 0x02)))
{
Store (0x02, Local1)
}
...
}
The i2c operation region is defined under I2C1 scope. _BST method under
battery device BATC read battery status from the field "FCG0". The request
would be sent to i2c operation region handler.
This patch is to add i2c ACPI operation region support. Due to there are
only "Byte" and "Bytes" protocol access on the Asus T100TA, other protocols
have not been tested.
About RawBytes and RawProcessBytes protocol, they needs specific drivers to interpret
reference data from AML code according ACPI 5.0 SPEC(5.5.2.4.5.3.9 and 5.5.2.4.5.3.10).
So far, not found such case and will add when find real case.
Signed-off-by: Lan Tianyu <tianyu.lan@intel.com>
Reviewed-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Signed-off-by: Wolfram Sang <wsa@the-dreams.de>
2014-05-20 20:59:23 +08:00
|
|
|
acpi_i2c_remove_space_handler(adap);
|
2008-01-28 01:14:49 +08:00
|
|
|
/* Tell drivers about this removal */
|
2009-06-19 22:58:19 +08:00
|
|
|
mutex_lock(&core_lock);
|
2013-03-09 16:16:44 +08:00
|
|
|
bus_for_each_drv(&i2c_bus_type, NULL, adap,
|
2009-12-07 00:06:27 +08:00
|
|
|
__process_removed_adapter);
|
2009-06-19 22:58:19 +08:00
|
|
|
mutex_unlock(&core_lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-11-26 16:22:33 +08:00
|
|
|
/* Remove devices instantiated from sysfs */
|
2012-09-10 16:14:02 +08:00
|
|
|
mutex_lock_nested(&adap->userspace_clients_lock,
|
|
|
|
i2c_adapter_depth(adap));
|
2010-05-04 17:09:28 +08:00
|
|
|
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);
|
2009-11-26 16:22:33 +08:00
|
|
|
}
|
2010-08-12 00:21:01 +08:00
|
|
|
mutex_unlock(&adap->userspace_clients_lock);
|
2009-11-26 16:22:33 +08:00
|
|
|
|
2009-06-19 22:58:19 +08:00
|
|
|
/* Detach any active clients. This can't fail, thus we do not
|
2011-01-15 05:03:49 +08:00
|
|
|
* 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. */
|
2013-03-09 16:16:44 +08:00
|
|
|
device_for_each_child(&adap->dev, NULL, __unregister_client);
|
|
|
|
device_for_each_child(&adap->dev, NULL, __unregister_dummy);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-19 04:45:46 +08:00
|
|
|
#ifdef CONFIG_I2C_COMPAT
|
|
|
|
class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
|
|
|
|
adap->dev.parent);
|
|
|
|
#endif
|
|
|
|
|
2010-01-17 03:43:13 +08:00
|
|
|
/* device name is gone after device_unregister */
|
|
|
|
dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* clean up the sysfs representation */
|
|
|
|
init_completion(&adap->dev_released);
|
|
|
|
device_unregister(&adap->dev);
|
|
|
|
|
|
|
|
/* wait for sysfs to drop all references */
|
|
|
|
wait_for_completion(&adap->dev_released);
|
|
|
|
|
2007-05-02 05:26:31 +08:00
|
|
|
/* free bus id */
|
2009-06-19 22:58:19 +08:00
|
|
|
mutex_lock(&core_lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
idr_remove(&i2c_adapter_idr, adap->nr);
|
2009-06-19 22:58:19 +08:00
|
|
|
mutex_unlock(&core_lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-07-17 01:30:05 +08:00
|
|
|
/* Clear the device structure in case this adapter is ever going to be
|
|
|
|
added again */
|
|
|
|
memset(&adap->dev, 0, sizeof(adap->dev));
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2007-05-02 05:26:31 +08:00
|
|
|
EXPORT_SYMBOL(i2c_del_adapter);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-05-02 05:26:30 +08:00
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
|
2011-03-20 21:50:52 +08:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(i2c_for_each_dev);
|
|
|
|
|
2009-12-07 00:06:27 +08:00
|
|
|
static int __process_new_driver(struct device *dev, void *data)
|
2008-07-15 04:38:19 +08:00
|
|
|
{
|
2009-09-19 04:45:46 +08:00
|
|
|
if (dev->type != &i2c_adapter_type)
|
|
|
|
return 0;
|
2009-12-07 00:06:27 +08:00
|
|
|
return i2c_do_add_adapter(data, to_i2c_adapter(dev));
|
2008-07-15 04:38:19 +08:00
|
|
|
}
|
|
|
|
|
2007-05-02 05:26:30 +08:00
|
|
|
/*
|
|
|
|
* An i2c_driver is used with one or more i2c_client (device) nodes to access
|
2009-06-19 22:58:18 +08:00
|
|
|
* i2c slave chips, on a bus instance associated with some i2c_adapter.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
|
2005-12-07 07:33:15 +08:00
|
|
|
int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-02-06 06:28:21 +08:00
|
|
|
int res;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-10-14 23:30:05 +08:00
|
|
|
/* Can't register until after driver model init */
|
|
|
|
if (unlikely(WARN_ON(!i2c_bus_type.p)))
|
|
|
|
return -EAGAIN;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* add the driver to the list of i2c drivers in the driver core */
|
2005-12-07 07:33:15 +08:00
|
|
|
driver->driver.owner = owner;
|
2005-04-17 06:20:36 +08:00
|
|
|
driver->driver.bus = &i2c_bus_type;
|
|
|
|
|
2009-06-19 22:58:18 +08:00
|
|
|
/* When registration returns, the driver core
|
2007-05-02 05:26:31 +08:00
|
|
|
* will have called probe() for all matching-but-unbound devices.
|
|
|
|
*/
|
2005-04-17 06:20:36 +08:00
|
|
|
res = driver_register(&driver->driver);
|
|
|
|
if (res)
|
2006-02-06 06:28:21 +08:00
|
|
|
return res;
|
2006-12-11 04:21:31 +08:00
|
|
|
|
2011-01-15 05:03:50 +08:00
|
|
|
/* Drivers should switch to dev_pm_ops instead. */
|
|
|
|
if (driver->suspend)
|
|
|
|
pr_warn("i2c-core: driver [%s] using legacy suspend method\n",
|
|
|
|
driver->driver.name);
|
|
|
|
if (driver->resume)
|
|
|
|
pr_warn("i2c-core: driver [%s] using legacy resume method\n",
|
|
|
|
driver->driver.name);
|
|
|
|
|
2005-11-27 03:34:05 +08:00
|
|
|
pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-15 04:38:36 +08:00
|
|
|
INIT_LIST_HEAD(&driver->clients);
|
|
|
|
/* Walk the adapters that are already present */
|
2011-03-20 21:50:52 +08:00
|
|
|
i2c_for_each_dev(driver, __process_new_driver);
|
2009-06-19 22:58:19 +08:00
|
|
|
|
2008-07-15 04:38:19 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(i2c_register_driver);
|
|
|
|
|
2009-12-07 00:06:27 +08:00
|
|
|
static int __process_removed_driver(struct device *dev, void *data)
|
2008-07-15 04:38:19 +08:00
|
|
|
{
|
2013-03-09 16:16:44 +08:00
|
|
|
if (dev->type == &i2c_adapter_type)
|
|
|
|
i2c_do_del_adapter(data, to_i2c_adapter(dev));
|
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2007-05-02 05:26:30 +08:00
|
|
|
/**
|
|
|
|
* i2c_del_driver - unregister I2C driver
|
|
|
|
* @driver: the driver being unregistered
|
2007-07-12 20:12:28 +08:00
|
|
|
* Context: can sleep
|
2007-05-02 05:26:30 +08:00
|
|
|
*/
|
2007-05-02 05:26:32 +08:00
|
|
|
void i2c_del_driver(struct i2c_driver *driver)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2011-03-20 21:50:52 +08:00
|
|
|
i2c_for_each_dev(driver, __process_removed_driver);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
driver_unregister(&driver->driver);
|
2005-11-27 03:34:05 +08:00
|
|
|
pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2007-05-02 05:26:31 +08:00
|
|
|
EXPORT_SYMBOL(i2c_del_driver);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-05-02 05:26:30 +08:00
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
|
2008-01-28 01:14:48 +08:00
|
|
|
/**
|
|
|
|
* 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)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-07-15 04:38:24 +08:00
|
|
|
if (client && get_device(&client->dev))
|
|
|
|
return client;
|
|
|
|
return NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2007-05-02 05:26:31 +08:00
|
|
|
EXPORT_SYMBOL(i2c_use_client);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-01-28 01:14:48 +08:00
|
|
|
/**
|
|
|
|
* 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)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-07-15 04:38:24 +08:00
|
|
|
if (client)
|
|
|
|
put_device(&client->dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2007-05-02 05:26:31 +08:00
|
|
|
EXPORT_SYMBOL(i2c_release_client);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-01-28 01:14:51 +08:00
|
|
|
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;
|
2013-09-29 16:51:06 +08:00
|
|
|
struct i2c_driver *driver;
|
|
|
|
|
|
|
|
if (!client || !client->dev.driver)
|
|
|
|
return 0;
|
2008-01-28 01:14:51 +08:00
|
|
|
|
2013-09-29 16:51:06 +08:00
|
|
|
driver = to_i2c_driver(client->dev.driver);
|
|
|
|
if (driver->command)
|
|
|
|
driver->command(client, arg->cmd, arg->arg);
|
2008-01-28 01:14:51 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
|
|
|
|
{
|
2008-01-28 01:14:51 +08:00
|
|
|
struct i2c_cmd_arg cmd_arg;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-01-28 01:14:51 +08:00
|
|
|
cmd_arg.cmd = cmd;
|
|
|
|
cmd_arg.arg = arg;
|
|
|
|
device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2007-05-02 05:26:31 +08:00
|
|
|
EXPORT_SYMBOL(i2c_clients_command);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
static int __init i2c_init(void)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
retval = bus_register(&i2c_bus_type);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
2009-09-19 04:45:46 +08:00
|
|
|
#ifdef CONFIG_I2C_COMPAT
|
|
|
|
i2c_adapter_compat_class = class_compat_register("i2c-adapter");
|
|
|
|
if (!i2c_adapter_compat_class) {
|
|
|
|
retval = -ENOMEM;
|
|
|
|
goto bus_err;
|
|
|
|
}
|
|
|
|
#endif
|
2008-01-28 01:14:52 +08:00
|
|
|
retval = i2c_add_driver(&dummy_driver);
|
|
|
|
if (retval)
|
2009-09-19 04:45:46 +08:00
|
|
|
goto class_err;
|
2008-01-28 01:14:52 +08:00
|
|
|
return 0;
|
|
|
|
|
2009-09-19 04:45:46 +08:00
|
|
|
class_err:
|
|
|
|
#ifdef CONFIG_I2C_COMPAT
|
|
|
|
class_compat_unregister(i2c_adapter_compat_class);
|
2008-01-28 01:14:52 +08:00
|
|
|
bus_err:
|
2009-09-19 04:45:46 +08:00
|
|
|
#endif
|
2008-01-28 01:14:52 +08:00
|
|
|
bus_unregister(&i2c_bus_type);
|
|
|
|
return retval;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit i2c_exit(void)
|
|
|
|
{
|
2008-01-28 01:14:52 +08:00
|
|
|
i2c_del_driver(&dummy_driver);
|
2009-09-19 04:45:46 +08:00
|
|
|
#ifdef CONFIG_I2C_COMPAT
|
|
|
|
class_compat_unregister(i2c_adapter_compat_class);
|
|
|
|
#endif
|
2005-04-17 06:20:36 +08:00
|
|
|
bus_unregister(&i2c_bus_type);
|
2014-03-06 21:35:59 +08:00
|
|
|
tracepoint_synchronize_unregister();
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-10-14 23:30:06 +08: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);
|
2005-04-17 06:20:36 +08:00
|
|
|
module_exit(i2c_exit);
|
|
|
|
|
|
|
|
/* ----------------------------------------------------
|
|
|
|
* the functional interface to the i2c busses.
|
|
|
|
* ----------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
2012-06-29 18:47:19 +08: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;
|
|
|
|
|
2014-03-06 21:35:59 +08:00
|
|
|
/* 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);
|
|
|
|
}
|
|
|
|
|
2012-06-29 18:47:19 +08:00
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|
2014-03-06 21:35:59 +08:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2012-06-29 18:47:19 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(__i2c_transfer);
|
|
|
|
|
2008-07-15 04:38:24 +08:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2009-03-29 04:34:46 +08:00
|
|
|
int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2012-06-29 18:47:19 +08:00
|
|
|
int ret;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-07-15 04:38:24 +08:00
|
|
|
/* 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).
|
|
|
|
*/
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if (adap->algo->master_xfer) {
|
|
|
|
#ifdef DEBUG
|
|
|
|
for (ret = 0; ret < num; ret++) {
|
|
|
|
dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
|
2007-05-02 05:26:29 +08:00
|
|
|
"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) ? "+" : "");
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-01-28 01:14:50 +08:00
|
|
|
if (in_atomic() || irqs_disabled()) {
|
2010-08-12 00:20:58 +08:00
|
|
|
ret = i2c_trylock_adapter(adap);
|
2008-01-28 01:14:50 +08:00
|
|
|
if (!ret)
|
|
|
|
/* I2C activity is ongoing. */
|
|
|
|
return -EAGAIN;
|
|
|
|
} else {
|
2010-08-12 00:20:58 +08:00
|
|
|
i2c_lock_adapter(adap);
|
2008-01-28 01:14:50 +08:00
|
|
|
}
|
|
|
|
|
2012-06-29 18:47:19 +08:00
|
|
|
ret = __i2c_transfer(adap, msgs, num);
|
2010-08-12 00:20:58 +08:00
|
|
|
i2c_unlock_adapter(adap);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
} else {
|
|
|
|
dev_dbg(&adap->dev, "I2C level transfers not supported\n");
|
2008-07-15 04:38:23 +08:00
|
|
|
return -EOPNOTSUPP;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
2007-05-02 05:26:31 +08:00
|
|
|
EXPORT_SYMBOL(i2c_transfer);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-07-15 04:38:24 +08:00
|
|
|
/**
|
|
|
|
* 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
|
2010-03-02 19:23:49 +08:00
|
|
|
* @count: How many bytes to write, must be less than 64k since msg.len is u16
|
2008-07-15 04:38:24 +08:00
|
|
|
*
|
|
|
|
* Returns negative errno, or else the number of bytes written.
|
|
|
|
*/
|
2011-01-11 05:11:23 +08:00
|
|
|
int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int ret;
|
2010-05-22 00:40:58 +08:00
|
|
|
struct i2c_adapter *adap = client->adapter;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct i2c_msg msg;
|
|
|
|
|
2005-05-08 04:58:46 +08:00
|
|
|
msg.addr = client->addr;
|
|
|
|
msg.flags = client->flags & I2C_M_TEN;
|
|
|
|
msg.len = count;
|
|
|
|
msg.buf = (char *)buf;
|
2006-12-11 04:21:31 +08:00
|
|
|
|
2005-05-08 04:58:46 +08:00
|
|
|
ret = i2c_transfer(adap, &msg, 1);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-03-16 01:11:05 +08:00
|
|
|
/*
|
|
|
|
* If everything went ok (i.e. 1 msg transmitted), return #bytes
|
|
|
|
* transmitted, else error code.
|
|
|
|
*/
|
2005-05-08 04:58:46 +08:00
|
|
|
return (ret == 1) ? count : ret;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2007-05-02 05:26:31 +08:00
|
|
|
EXPORT_SYMBOL(i2c_master_send);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-07-15 04:38:24 +08:00
|
|
|
/**
|
|
|
|
* 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
|
2010-03-02 19:23:49 +08:00
|
|
|
* @count: How many bytes to read, must be less than 64k since msg.len is u16
|
2008-07-15 04:38:24 +08:00
|
|
|
*
|
|
|
|
* Returns negative errno, or else the number of bytes read.
|
|
|
|
*/
|
2011-01-11 05:11:23 +08:00
|
|
|
int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2010-05-22 00:40:58 +08:00
|
|
|
struct i2c_adapter *adap = client->adapter;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct i2c_msg msg;
|
|
|
|
int ret;
|
2005-05-08 04:58:46 +08:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
2012-03-16 01:11:05 +08:00
|
|
|
/*
|
|
|
|
* If everything went ok (i.e. 1 msg received), return #bytes received,
|
|
|
|
* else error code.
|
|
|
|
*/
|
2005-05-08 04:58:46 +08:00
|
|
|
return (ret == 1) ? count : ret;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2007-05-02 05:26:31 +08:00
|
|
|
EXPORT_SYMBOL(i2c_master_recv);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* ----------------------------------------------------
|
|
|
|
* the i2c address scanning function
|
|
|
|
* Will not work for 10-bit addresses!
|
|
|
|
* ----------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
2010-06-03 17:33:51 +08:00
|
|
|
/*
|
|
|
|
* 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
|
2010-08-12 00:21:00 +08:00
|
|
|
if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
|
|
|
|
&& i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
|
2010-06-03 17:33:51 +08:00
|
|
|
err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
|
|
|
|
I2C_SMBUS_QUICK, NULL);
|
2010-08-12 00:21:00 +08:00
|
|
|
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 {
|
2013-07-18 04:27:59 +08:00
|
|
|
dev_warn(&adap->dev, "No suitable probing method supported for address 0x%02X\n",
|
|
|
|
addr);
|
2010-08-12 00:21:00 +08:00
|
|
|
err = -EOPNOTSUPP;
|
|
|
|
}
|
2010-06-03 17:33:51 +08:00
|
|
|
|
|
|
|
return err >= 0;
|
|
|
|
}
|
|
|
|
|
2009-12-07 00:06:25 +08:00
|
|
|
static int i2c_detect_address(struct i2c_client *temp_client,
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-15 04:38:36 +08:00
|
|
|
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 */
|
2010-06-03 17:33:53 +08:00
|
|
|
err = i2c_check_addr_validity(addr);
|
|
|
|
if (err) {
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-15 04:38:36 +08:00
|
|
|
dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
|
|
|
|
addr);
|
2010-06-03 17:33:53 +08:00
|
|
|
return err;
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-15 04:38:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Skip if already in use */
|
2010-06-03 17:33:55 +08:00
|
|
|
if (i2c_check_addr_busy(adapter, addr))
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-15 04:38:36 +08:00
|
|
|
return 0;
|
|
|
|
|
2009-12-07 00:06:25 +08:00
|
|
|
/* Make sure there is something at this address */
|
2010-06-03 17:33:51 +08:00
|
|
|
if (!i2c_default_probe(adapter, addr))
|
|
|
|
return 0;
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-15 04:38:36 +08:00
|
|
|
|
|
|
|
/* Finally call the custom detection function */
|
|
|
|
memset(&info, 0, sizeof(struct i2c_board_info));
|
|
|
|
info.addr = addr;
|
2009-12-15 04:17:23 +08:00
|
|
|
err = driver->detect(temp_client, &info);
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-15 04:38:36 +08:00
|
|
|
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 */
|
2014-02-10 18:03:56 +08:00
|
|
|
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);
|
|
|
|
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-15 04:38:36 +08:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
|
|
|
|
{
|
2009-12-15 04:17:25 +08:00
|
|
|
const unsigned short *address_list;
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-15 04:38:36 +08:00
|
|
|
struct i2c_client *temp_client;
|
|
|
|
int i, err = 0;
|
|
|
|
int adap_id = i2c_adapter_id(adapter);
|
|
|
|
|
2009-12-15 04:17:25 +08:00
|
|
|
address_list = driver->address_list;
|
|
|
|
if (!driver->detect || !address_list)
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-15 04:38:36 +08:00
|
|
|
return 0;
|
|
|
|
|
2014-07-10 19:46:21 +08:00
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|
2010-10-25 00:16:58 +08:00
|
|
|
/* Stop here if the classes do not match */
|
|
|
|
if (!(adapter->class & driver->class))
|
|
|
|
return 0;
|
|
|
|
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-15 04:38:36 +08:00
|
|
|
/* 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;
|
|
|
|
|
2009-12-15 04:17:25 +08:00
|
|
|
for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-15 04:38:36 +08:00
|
|
|
dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
|
2009-12-15 04:17:25 +08:00
|
|
|
"addr 0x%02x\n", adap_id, address_list[i]);
|
|
|
|
temp_client->addr = address_list[i];
|
2009-12-07 00:06:25 +08:00
|
|
|
err = i2c_detect_address(temp_client, driver);
|
2010-10-25 00:16:58 +08:00
|
|
|
if (unlikely(err))
|
|
|
|
break;
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-15 04:38:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
kfree(temp_client);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2010-08-12 00:20:57 +08: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;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
|
|
|
|
|
2007-05-02 05:26:31 +08:00
|
|
|
struct i2c_client *
|
|
|
|
i2c_new_probed_device(struct i2c_adapter *adap,
|
|
|
|
struct i2c_board_info *info,
|
2010-08-12 00:20:56 +08:00
|
|
|
unsigned short const *addr_list,
|
|
|
|
int (*probe)(struct i2c_adapter *, unsigned short addr))
|
2007-05-02 05:26:31 +08:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2010-08-12 00:21:00 +08:00
|
|
|
if (!probe)
|
2010-08-12 00:20:56 +08:00
|
|
|
probe = i2c_default_probe;
|
2007-05-02 05:26:31 +08:00
|
|
|
|
|
|
|
for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
|
|
|
|
/* Check address validity */
|
2010-06-03 17:33:53 +08:00
|
|
|
if (i2c_check_addr_validity(addr_list[i]) < 0) {
|
2007-05-02 05:26:31 +08:00
|
|
|
dev_warn(&adap->dev, "Invalid 7-bit address "
|
|
|
|
"0x%02x\n", addr_list[i]);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check address availability */
|
2010-06-03 17:33:55 +08:00
|
|
|
if (i2c_check_addr_busy(adap, addr_list[i])) {
|
2007-05-02 05:26:31 +08:00
|
|
|
dev_dbg(&adap->dev, "Address 0x%02x already in "
|
|
|
|
"use, not probing\n", addr_list[i]);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2010-06-03 17:33:51 +08:00
|
|
|
/* Test address responsiveness */
|
2010-08-12 00:20:56 +08:00
|
|
|
if (probe(adap, addr_list[i]))
|
2010-06-03 17:33:51 +08:00
|
|
|
break;
|
2007-05-02 05:26:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(i2c_new_probed_device);
|
|
|
|
|
2011-03-20 21:50:52 +08:00
|
|
|
struct i2c_adapter *i2c_get_adapter(int nr)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct i2c_adapter *adapter;
|
2006-12-11 04:21:31 +08:00
|
|
|
|
2008-01-28 01:14:49 +08:00
|
|
|
mutex_lock(&core_lock);
|
2011-03-20 21:50:52 +08:00
|
|
|
adapter = idr_find(&i2c_adapter_idr, nr);
|
2005-06-28 12:21:30 +08:00
|
|
|
if (adapter && !try_module_get(adapter->owner))
|
|
|
|
adapter = NULL;
|
|
|
|
|
2008-01-28 01:14:49 +08:00
|
|
|
mutex_unlock(&core_lock);
|
2005-06-28 12:21:30 +08:00
|
|
|
return adapter;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2007-05-02 05:26:31 +08:00
|
|
|
EXPORT_SYMBOL(i2c_get_adapter);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
void i2c_put_adapter(struct i2c_adapter *adap)
|
|
|
|
{
|
2013-08-01 20:10:46 +08:00
|
|
|
if (adap)
|
|
|
|
module_put(adap->owner);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2007-05-02 05:26:31 +08:00
|
|
|
EXPORT_SYMBOL(i2c_put_adapter);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* The SMBus parts */
|
|
|
|
|
2006-12-11 04:21:31 +08:00
|
|
|
#define POLY (0x1070U << 3)
|
2009-03-29 04:34:46 +08:00
|
|
|
static u8 crc8(u16 data)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int i;
|
2006-12-11 04:21:31 +08:00
|
|
|
|
2010-05-22 00:40:58 +08:00
|
|
|
for (i = 0; i < 8; i++) {
|
2006-12-11 04:21:31 +08:00
|
|
|
if (data & 0x8000)
|
2005-04-17 06:20:36 +08:00
|
|
|
data = data ^ POLY;
|
|
|
|
data = data << 1;
|
|
|
|
}
|
|
|
|
return (u8)(data >> 8);
|
|
|
|
}
|
|
|
|
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-27 03:28:55 +08: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)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2010-05-22 00:40:58 +08:00
|
|
|
for (i = 0; i < count; i++)
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-27 03:28:55 +08:00
|
|
|
crc = crc8((crc ^ p[i]) << 8);
|
2005-04-17 06:20:36 +08:00
|
|
|
return crc;
|
|
|
|
}
|
|
|
|
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-27 03:28:55 +08:00
|
|
|
/* Assume a 7-bit address, which is reasonable for SMBus */
|
|
|
|
static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-27 03:28:55 +08:00
|
|
|
/* The address will be sent first */
|
|
|
|
u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
|
|
|
|
pec = i2c_smbus_pec(pec, &addr, 1);
|
|
|
|
|
|
|
|
/* The data buffer follows */
|
|
|
|
return i2c_smbus_pec(pec, msg->buf, msg->len);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-27 03:28:55 +08:00
|
|
|
/* Used for write only transactions */
|
|
|
|
static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-27 03:28:55 +08:00
|
|
|
msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
|
|
|
|
msg->len++;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-27 03:28:55 +08: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)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-27 03:28:55 +08:00
|
|
|
u8 rpec = msg->buf[--msg->len];
|
|
|
|
cpec = i2c_smbus_msg_pec(cpec, msg);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (rpec != cpec) {
|
|
|
|
pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
|
|
|
|
rpec, cpec);
|
2008-07-15 04:38:23 +08:00
|
|
|
return -EBADMSG;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2006-12-11 04:21:31 +08:00
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-07-15 04:38:24 +08: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.
|
|
|
|
*/
|
2011-01-11 05:11:23 +08:00
|
|
|
s32 i2c_smbus_read_byte(const struct i2c_client *client)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
union i2c_smbus_data data;
|
2008-07-15 04:38:23 +08:00
|
|
|
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;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2007-05-02 05:26:31 +08:00
|
|
|
EXPORT_SYMBOL(i2c_smbus_read_byte);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-07-15 04:38:24 +08:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2011-01-11 05:11:23 +08:00
|
|
|
s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2010-05-22 00:40:58 +08:00
|
|
|
return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-27 03:28:55 +08:00
|
|
|
I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2007-05-02 05:26:31 +08:00
|
|
|
EXPORT_SYMBOL(i2c_smbus_write_byte);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-07-15 04:38:24 +08:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2011-01-11 05:11:23 +08:00
|
|
|
s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
union i2c_smbus_data data;
|
2008-07-15 04:38:23 +08:00
|
|
|
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;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2007-05-02 05:26:31 +08:00
|
|
|
EXPORT_SYMBOL(i2c_smbus_read_byte_data);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-07-15 04:38:24 +08:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2011-01-11 05:11:23 +08:00
|
|
|
s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
|
|
|
|
u8 value)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
union i2c_smbus_data data;
|
|
|
|
data.byte = value;
|
2010-05-22 00:40:58 +08:00
|
|
|
return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
|
|
|
|
I2C_SMBUS_WRITE, command,
|
|
|
|
I2C_SMBUS_BYTE_DATA, &data);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2007-05-02 05:26:31 +08:00
|
|
|
EXPORT_SYMBOL(i2c_smbus_write_byte_data);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-07-15 04:38:24 +08:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2011-01-11 05:11:23 +08:00
|
|
|
s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
union i2c_smbus_data data;
|
2008-07-15 04:38:23 +08:00
|
|
|
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;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2007-05-02 05:26:31 +08:00
|
|
|
EXPORT_SYMBOL(i2c_smbus_read_word_data);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-07-15 04:38:24 +08:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2011-01-11 05:11:23 +08:00
|
|
|
s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
|
|
|
|
u16 value)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
union i2c_smbus_data data;
|
|
|
|
data.word = value;
|
2010-05-22 00:40:58 +08:00
|
|
|
return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
|
|
|
|
I2C_SMBUS_WRITE, command,
|
|
|
|
I2C_SMBUS_WORD_DATA, &data);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2007-05-02 05:26:31 +08:00
|
|
|
EXPORT_SYMBOL(i2c_smbus_write_word_data);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-10-14 05:56:31 +08:00
|
|
|
/**
|
2008-07-15 04:38:24 +08:00
|
|
|
* i2c_smbus_read_block_data - SMBus "block read" protocol
|
2007-10-14 05:56:31 +08:00
|
|
|
* @client: Handle to slave device
|
2008-07-15 04:38:24 +08:00
|
|
|
* @command: Byte interpreted by slave
|
2007-10-14 05:56:31 +08:00
|
|
|
* @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.
|
|
|
|
*
|
2008-07-15 04:38:24 +08:00
|
|
|
* This executes the SMBus "block read" protocol, returning negative errno
|
|
|
|
* else the number of data bytes in the slave's response.
|
2007-10-14 05:56:31 +08:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
2011-01-11 05:11:23 +08:00
|
|
|
s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
|
2007-05-02 05:26:34 +08:00
|
|
|
u8 *values)
|
|
|
|
{
|
|
|
|
union i2c_smbus_data data;
|
2008-07-15 04:38:23 +08:00
|
|
|
int status;
|
2007-05-02 05:26:34 +08:00
|
|
|
|
2008-07-15 04:38:23 +08:00
|
|
|
status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
|
|
|
|
I2C_SMBUS_READ, command,
|
|
|
|
I2C_SMBUS_BLOCK_DATA, &data);
|
|
|
|
if (status)
|
|
|
|
return status;
|
2007-05-02 05:26:34 +08:00
|
|
|
|
|
|
|
memcpy(values, &data.block[1], data.block[0]);
|
|
|
|
return data.block[0];
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(i2c_smbus_read_block_data);
|
|
|
|
|
2008-07-15 04:38:24 +08:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2011-01-11 05:11:23 +08:00
|
|
|
s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
|
2006-06-13 03:42:20 +08:00
|
|
|
u8 length, const u8 *values)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
union i2c_smbus_data data;
|
2006-01-19 06:14:55 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if (length > I2C_SMBUS_BLOCK_MAX)
|
|
|
|
length = I2C_SMBUS_BLOCK_MAX;
|
|
|
|
data.block[0] = length;
|
2006-01-19 06:14:55 +08:00
|
|
|
memcpy(&data.block[1], values, length);
|
2010-05-22 00:40:58 +08:00
|
|
|
return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
|
|
|
|
I2C_SMBUS_WRITE, command,
|
|
|
|
I2C_SMBUS_BLOCK_DATA, &data);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2007-05-02 05:26:31 +08:00
|
|
|
EXPORT_SYMBOL(i2c_smbus_write_block_data);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Returns the number of read bytes */
|
2011-01-11 05:11:23 +08:00
|
|
|
s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
|
i2c: Fix the i2c_smbus_read_i2c_block_data() prototype
Let the drivers specify how many bytes they want to read with
i2c_smbus_read_i2c_block_data(). So far, the block count was
hard-coded to I2C_SMBUS_BLOCK_MAX (32), which did not make much sense.
Many driver authors complained about this before, and I believe it's
about time to fix it. Right now, authors have to do technically stupid
things, such as individual byte reads or full-fledged I2C messaging,
to work around the problem. We do not want to encourage that.
I even found that some bus drivers (e.g. i2c-amd8111) already
implemented I2C block read the "right" way, that is, they didn't
follow the old, broken standard. The fact that it was never noticed
before just shows how little i2c_smbus_read_i2c_block_data() was used,
which isn't that surprising given how broken its prototype was so far.
There are some obvious compatiblity considerations:
* This changes the i2c_smbus_read_i2c_block_data() prototype. Users
outside the kernel tree will notice at compilation time, and will
have to update their code.
* User-space has access to i2c_smbus_xfer() directly using i2c-dev, so
the changed expectations would affect tools such as i2cdump. In order
to preserve binary compatibility, we give I2C_SMBUS_I2C_BLOCK_DATA
a new numeric value, and define I2C_SMBUS_I2C_BLOCK_BROKEN with the
old numeric value. When i2c-dev receives a transaction with the
old value, it can convert it to the new format on the fly.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-07-12 20:12:29 +08:00
|
|
|
u8 length, u8 *values)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
union i2c_smbus_data data;
|
2008-07-15 04:38:23 +08:00
|
|
|
int status;
|
2006-01-19 06:14:55 +08:00
|
|
|
|
i2c: Fix the i2c_smbus_read_i2c_block_data() prototype
Let the drivers specify how many bytes they want to read with
i2c_smbus_read_i2c_block_data(). So far, the block count was
hard-coded to I2C_SMBUS_BLOCK_MAX (32), which did not make much sense.
Many driver authors complained about this before, and I believe it's
about time to fix it. Right now, authors have to do technically stupid
things, such as individual byte reads or full-fledged I2C messaging,
to work around the problem. We do not want to encourage that.
I even found that some bus drivers (e.g. i2c-amd8111) already
implemented I2C block read the "right" way, that is, they didn't
follow the old, broken standard. The fact that it was never noticed
before just shows how little i2c_smbus_read_i2c_block_data() was used,
which isn't that surprising given how broken its prototype was so far.
There are some obvious compatiblity considerations:
* This changes the i2c_smbus_read_i2c_block_data() prototype. Users
outside the kernel tree will notice at compilation time, and will
have to update their code.
* User-space has access to i2c_smbus_xfer() directly using i2c-dev, so
the changed expectations would affect tools such as i2cdump. In order
to preserve binary compatibility, we give I2C_SMBUS_I2C_BLOCK_DATA
a new numeric value, and define I2C_SMBUS_I2C_BLOCK_BROKEN with the
old numeric value. When i2c-dev receives a transaction with the
old value, it can convert it to the new format on the fly.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-07-12 20:12:29 +08:00
|
|
|
if (length > I2C_SMBUS_BLOCK_MAX)
|
|
|
|
length = I2C_SMBUS_BLOCK_MAX;
|
|
|
|
data.block[0] = length;
|
2008-07-15 04:38:23 +08:00
|
|
|
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;
|
2006-01-19 06:14:55 +08:00
|
|
|
|
|
|
|
memcpy(values, &data.block[1], data.block[0]);
|
|
|
|
return data.block[0];
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2007-05-02 05:26:31 +08:00
|
|
|
EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2011-01-11 05:11:23 +08:00
|
|
|
s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
|
2006-06-13 03:42:20 +08:00
|
|
|
u8 length, const u8 *values)
|
2006-01-09 12:19:18 +08:00
|
|
|
{
|
|
|
|
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);
|
|
|
|
}
|
2007-05-02 05:26:31 +08:00
|
|
|
EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
|
2006-01-09 12:19:18 +08:00
|
|
|
|
2006-12-11 04:21:31 +08:00
|
|
|
/* Simulate a SMBus command using the i2c protocol
|
2005-04-17 06:20:36 +08:00
|
|
|
No checking of parameters is done! */
|
2010-05-22 00:40:58 +08:00
|
|
|
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)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
/* 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. */
|
2005-09-25 23:01:11 +08:00
|
|
|
unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
|
|
|
|
unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
|
2010-05-22 00:40:58 +08:00
|
|
|
int num = read_write == I2C_SMBUS_READ ? 2 : 1;
|
2005-04-17 06:20:36 +08:00
|
|
|
int i;
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-27 03:28:55 +08:00
|
|
|
u8 partial_pec = 0;
|
2008-07-15 04:38:23 +08:00
|
|
|
int status;
|
2012-10-06 04:23:52 +08:00
|
|
|
struct i2c_msg msg[2] = {
|
|
|
|
{
|
|
|
|
.addr = addr,
|
|
|
|
.flags = flags,
|
|
|
|
.len = 1,
|
|
|
|
.buf = msgbuf0,
|
|
|
|
}, {
|
|
|
|
.addr = addr,
|
|
|
|
.flags = flags | I2C_M_RD,
|
|
|
|
.len = 0,
|
|
|
|
.buf = msgbuf1,
|
|
|
|
},
|
|
|
|
};
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
msgbuf0[0] = command;
|
2010-05-22 00:40:58 +08:00
|
|
|
switch (size) {
|
2005-04-17 06:20:36 +08:00
|
|
|
case I2C_SMBUS_QUICK:
|
|
|
|
msg[0].len = 0;
|
|
|
|
/* Special case: The read/write field is used as data */
|
2009-02-25 02:19:48 +08:00
|
|
|
msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
|
|
|
|
I2C_M_RD : 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
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 {
|
2010-05-22 00:40:58 +08:00
|
|
|
msg[0].len = 3;
|
2005-04-17 06:20:36 +08:00
|
|
|
msgbuf0[1] = data->word & 0xff;
|
2006-09-04 04:24:00 +08:00
|
|
|
msgbuf0[2] = data->word >> 8;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
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;
|
2006-09-04 04:24:00 +08:00
|
|
|
msgbuf0[2] = data->word >> 8;
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
case I2C_SMBUS_BLOCK_DATA:
|
|
|
|
if (read_write == I2C_SMBUS_READ) {
|
2007-05-02 05:26:29 +08:00
|
|
|
msg[1].flags |= I2C_M_RECV_LEN;
|
|
|
|
msg[1].len = 1; /* block length will be added by
|
|
|
|
the underlying bus driver */
|
2005-04-17 06:20:36 +08:00
|
|
|
} else {
|
|
|
|
msg[0].len = data->block[0] + 2;
|
|
|
|
if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
|
2008-07-15 04:38:23 +08:00
|
|
|
dev_err(&adapter->dev,
|
|
|
|
"Invalid block write size %d\n",
|
|
|
|
data->block[0]);
|
|
|
|
return -EINVAL;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2005-09-25 23:01:11 +08:00
|
|
|
for (i = 1; i < msg[0].len; i++)
|
2005-04-17 06:20:36 +08:00
|
|
|
msgbuf0[i] = data->block[i-1];
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case I2C_SMBUS_BLOCK_PROC_CALL:
|
2007-05-02 05:26:29 +08:00
|
|
|
num = 2; /* Another special case */
|
|
|
|
read_write = I2C_SMBUS_READ;
|
|
|
|
if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
|
2008-07-15 04:38:23 +08:00
|
|
|
dev_err(&adapter->dev,
|
|
|
|
"Invalid block write size %d\n",
|
2007-05-02 05:26:29 +08:00
|
|
|
data->block[0]);
|
2008-07-15 04:38:23 +08:00
|
|
|
return -EINVAL;
|
2007-05-02 05:26:29 +08:00
|
|
|
}
|
|
|
|
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;
|
2005-04-17 06:20:36 +08:00
|
|
|
case I2C_SMBUS_I2C_BLOCK_DATA:
|
|
|
|
if (read_write == I2C_SMBUS_READ) {
|
i2c: Fix the i2c_smbus_read_i2c_block_data() prototype
Let the drivers specify how many bytes they want to read with
i2c_smbus_read_i2c_block_data(). So far, the block count was
hard-coded to I2C_SMBUS_BLOCK_MAX (32), which did not make much sense.
Many driver authors complained about this before, and I believe it's
about time to fix it. Right now, authors have to do technically stupid
things, such as individual byte reads or full-fledged I2C messaging,
to work around the problem. We do not want to encourage that.
I even found that some bus drivers (e.g. i2c-amd8111) already
implemented I2C block read the "right" way, that is, they didn't
follow the old, broken standard. The fact that it was never noticed
before just shows how little i2c_smbus_read_i2c_block_data() was used,
which isn't that surprising given how broken its prototype was so far.
There are some obvious compatiblity considerations:
* This changes the i2c_smbus_read_i2c_block_data() prototype. Users
outside the kernel tree will notice at compilation time, and will
have to update their code.
* User-space has access to i2c_smbus_xfer() directly using i2c-dev, so
the changed expectations would affect tools such as i2cdump. In order
to preserve binary compatibility, we give I2C_SMBUS_I2C_BLOCK_DATA
a new numeric value, and define I2C_SMBUS_I2C_BLOCK_BROKEN with the
old numeric value. When i2c-dev receives a transaction with the
old value, it can convert it to the new format on the fly.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-07-12 20:12:29 +08:00
|
|
|
msg[1].len = data->block[0];
|
2005-04-17 06:20:36 +08:00
|
|
|
} else {
|
|
|
|
msg[0].len = data->block[0] + 1;
|
2005-10-08 06:15:59 +08:00
|
|
|
if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
|
2008-07-15 04:38:23 +08:00
|
|
|
dev_err(&adapter->dev,
|
|
|
|
"Invalid block write size %d\n",
|
|
|
|
data->block[0]);
|
|
|
|
return -EINVAL;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
for (i = 1; i <= data->block[0]; i++)
|
|
|
|
msgbuf0[i] = data->block[i];
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
2008-07-15 04:38:23 +08:00
|
|
|
dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
|
|
|
|
return -EOPNOTSUPP;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-27 03:28:55 +08:00
|
|
|
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)) {
|
2006-12-11 04:21:31 +08:00
|
|
|
if (num == 1) /* Write only */
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-27 03:28:55 +08:00
|
|
|
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)
|
2006-12-11 04:21:31 +08:00
|
|
|
msg[num-1].len++;
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-27 03:28:55 +08:00
|
|
|
}
|
|
|
|
|
2008-07-15 04:38:23 +08:00
|
|
|
status = i2c_transfer(adapter, msg, num);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-27 03:28:55 +08:00
|
|
|
/* Check PEC if last message is a read */
|
|
|
|
if (i && (msg[num-1].flags & I2C_M_RD)) {
|
2008-07-15 04:38:23 +08:00
|
|
|
status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-27 03:28:55 +08:00
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if (read_write == I2C_SMBUS_READ)
|
2010-05-22 00:40:58 +08:00
|
|
|
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;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-07-15 04:38:24 +08: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.
|
|
|
|
*/
|
2009-03-29 04:34:46 +08:00
|
|
|
s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
|
2008-07-15 04:38:24 +08:00
|
|
|
char read_write, u8 command, int protocol,
|
2009-03-29 04:34:46 +08:00
|
|
|
union i2c_smbus_data *data)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-06-16 00:01:46 +08:00
|
|
|
unsigned long orig_jiffies;
|
|
|
|
int try;
|
2005-04-17 06:20:36 +08:00
|
|
|
s32 res;
|
|
|
|
|
2014-03-06 21:36:06 +08:00
|
|
|
/* 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);
|
|
|
|
|
2012-07-24 20:13:59 +08:00
|
|
|
flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (adapter->algo->smbus_xfer) {
|
2010-08-12 00:20:58 +08:00
|
|
|
i2c_lock_adapter(adapter);
|
2009-06-16 00:01:46 +08:00
|
|
|
|
|
|
|
/* 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;
|
|
|
|
}
|
2010-08-12 00:20:58 +08:00
|
|
|
i2c_unlock_adapter(adapter);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-07-24 20:13:59 +08:00
|
|
|
if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
|
2014-03-06 21:36:06 +08:00
|
|
|
goto trace;
|
2012-07-24 20:13:59 +08:00
|
|
|
/*
|
|
|
|
* Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
|
|
|
|
* implement native support for the SMBus operation.
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
|
2014-03-06 21:36:06 +08:00
|
|
|
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;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(i2c_smbus_xfer);
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
|
|
|
|
MODULE_DESCRIPTION("I2C-Bus main module");
|
|
|
|
MODULE_LICENSE("GPL");
|