mirror of https://gitee.com/openkylin/linux.git
Input: synaptics-rmi4 - add SMBus support
Code obtained from https://raw.githubusercontent.com/mightybigcar/synaptics-rmi4/jf/drivers/input/rmi4/rmi_smbus.c and updated to match upstream. And fixed to make it work. Signed-off-by: Benjamin Tissoires <benjamin.tissoires@redhat.com> Signed-off-by: Andrew Duggan <aduggan@synaptics.com> Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
This commit is contained in:
Benjamin Tissoires
Dmitry Torokhov
parent
332c3988fe
commit
82264d0cf7
|
|
@ -27,6 +27,18 @@ config RMI4_SPI
|
|||
|
||||
If unsure, say N.
|
||||
|
||||
config RMI4_SMB
|
||||
tristate "RMI4 SMB Support"
|
||||
depends on RMI4_CORE && I2C
|
||||
help
|
||||
Say Y here if you want to support RMI4 devices connected to an SMB
|
||||
bus.
|
||||
|
||||
If unsure, say N.
|
||||
|
||||
To compile this driver as a module, choose M here: the module will be
|
||||
called rmi_smbus.
|
||||
|
||||
config RMI4_2D_SENSOR
|
||||
bool
|
||||
depends on RMI4_CORE
|
||||
|
|
|
|||
|
|
@ -12,3 +12,4 @@ rmi_core-$(CONFIG_RMI4_F54) += rmi_f54.o
|
|||
# Transports
|
||||
obj-$(CONFIG_RMI4_I2C) += rmi_i2c.o
|
||||
obj-$(CONFIG_RMI4_SPI) += rmi_spi.o
|
||||
obj-$(CONFIG_RMI4_SMB) += rmi_smbus.o
|
||||
|
|
|
|||
|
|
@ -104,6 +104,18 @@ rmi_get_platform_data(struct rmi_device *d)
|
|||
|
||||
bool rmi_is_physical_device(struct device *dev);
|
||||
|
||||
/**
|
||||
* rmi_reset - reset a RMI4 device
|
||||
* @d: Pointer to an RMI device
|
||||
*
|
||||
* Calls for a reset of each function implemented by a specific device.
|
||||
* Returns 0 on success or a negative error code.
|
||||
*/
|
||||
static inline int rmi_reset(struct rmi_device *d)
|
||||
{
|
||||
return d->driver->reset_handler(d);
|
||||
}
|
||||
|
||||
/**
|
||||
* rmi_read - read a single byte
|
||||
* @d: Pointer to an RMI device
|
||||
|
|
|
|||
|
|
@ -0,0 +1,447 @@
|
|||
/*
|
||||
* Copyright (c) 2015 - 2016 Red Hat, Inc
|
||||
* Copyright (c) 2011, 2012 Synaptics Incorporated
|
||||
* Copyright (c) 2011 Unixphere
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 as published by
|
||||
* the Free Software Foundation.
|
||||
*/
|
||||
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/delay.h>
|
||||
#include <linux/i2c.h>
|
||||
#include <linux/interrupt.h>
|
||||
#include <linux/kconfig.h>
|
||||
#include <linux/lockdep.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/pm.h>
|
||||
#include <linux/rmi.h>
|
||||
#include <linux/slab.h>
|
||||
#include "rmi_driver.h"
|
||||
|
||||
#define SMB_PROTOCOL_VERSION_ADDRESS 0xfd
|
||||
#define SMB_MAX_COUNT 32
|
||||
#define RMI_SMB2_MAP_SIZE 8 /* 8 entry of 4 bytes each */
|
||||
#define RMI_SMB2_MAP_FLAGS_WE 0x01
|
||||
|
||||
struct mapping_table_entry {
|
||||
__le16 rmiaddr;
|
||||
u8 readcount;
|
||||
u8 flags;
|
||||
};
|
||||
|
||||
struct rmi_smb_xport {
|
||||
struct rmi_transport_dev xport;
|
||||
struct i2c_client *client;
|
||||
|
||||
struct mutex page_mutex;
|
||||
int page;
|
||||
u8 table_index;
|
||||
struct mutex mappingtable_mutex;
|
||||
struct mapping_table_entry mapping_table[RMI_SMB2_MAP_SIZE];
|
||||
};
|
||||
|
||||
static int rmi_smb_get_version(struct rmi_smb_xport *rmi_smb)
|
||||
{
|
||||
struct i2c_client *client = rmi_smb->client;
|
||||
int retval;
|
||||
|
||||
/* Check if for SMBus new version device by reading version byte. */
|
||||
retval = i2c_smbus_read_byte_data(client, SMB_PROTOCOL_VERSION_ADDRESS);
|
||||
if (retval < 0) {
|
||||
dev_err(&client->dev, "failed to get SMBus version number!\n");
|
||||
return retval;
|
||||
}
|
||||
return retval + 1;
|
||||
}
|
||||
|
||||
/* SMB block write - wrapper over ic2_smb_write_block */
|
||||
static int smb_block_write(struct rmi_transport_dev *xport,
|
||||
u8 commandcode, const void *buf, size_t len)
|
||||
{
|
||||
struct rmi_smb_xport *rmi_smb =
|
||||
container_of(xport, struct rmi_smb_xport, xport);
|
||||
struct i2c_client *client = rmi_smb->client;
|
||||
int retval;
|
||||
|
||||
retval = i2c_smbus_write_block_data(client, commandcode, len, buf);
|
||||
|
||||
rmi_dbg(RMI_DEBUG_XPORT, &client->dev,
|
||||
"wrote %zd bytes at %#04x: %d (%*ph)\n",
|
||||
len, commandcode, retval, (int)len, buf);
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
/*
|
||||
* The function to get command code for smbus operations and keeps
|
||||
* records to the driver mapping table
|
||||
*/
|
||||
static int rmi_smb_get_command_code(struct rmi_transport_dev *xport,
|
||||
u16 rmiaddr, int bytecount, bool isread, u8 *commandcode)
|
||||
{
|
||||
struct rmi_smb_xport *rmi_smb =
|
||||
container_of(xport, struct rmi_smb_xport, xport);
|
||||
int i;
|
||||
int retval;
|
||||
struct mapping_table_entry mapping_data[1];
|
||||
|
||||
mutex_lock(&rmi_smb->mappingtable_mutex);
|
||||
for (i = 0; i < RMI_SMB2_MAP_SIZE; i++) {
|
||||
if (rmi_smb->mapping_table[i].rmiaddr == rmiaddr) {
|
||||
if (isread) {
|
||||
if (rmi_smb->mapping_table[i].readcount
|
||||
== bytecount) {
|
||||
*commandcode = i;
|
||||
retval = 0;
|
||||
goto exit;
|
||||
}
|
||||
} else {
|
||||
if (rmi_smb->mapping_table[i].flags &
|
||||
RMI_SMB2_MAP_FLAGS_WE) {
|
||||
*commandcode = i;
|
||||
retval = 0;
|
||||
goto exit;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
i = rmi_smb->table_index;
|
||||
rmi_smb->table_index = (i + 1) % RMI_SMB2_MAP_SIZE;
|
||||
|
||||
/* constructs mapping table data entry. 4 bytes each entry */
|
||||
memset(mapping_data, 0, sizeof(mapping_data));
|
||||
|
||||
mapping_data[0].rmiaddr = cpu_to_le16(rmiaddr);
|
||||
mapping_data[0].readcount = bytecount;
|
||||
mapping_data[0].flags = !isread ? RMI_SMB2_MAP_FLAGS_WE : 0;
|
||||
|
||||
retval = smb_block_write(xport, i + 0x80, mapping_data,
|
||||
sizeof(mapping_data));
|
||||
|
||||
if (retval < 0) {
|
||||
/*
|
||||
* if not written to device mapping table
|
||||
* clear the driver mapping table records
|
||||
*/
|
||||
rmi_smb->mapping_table[i].rmiaddr = 0x0000;
|
||||
rmi_smb->mapping_table[i].readcount = 0;
|
||||
rmi_smb->mapping_table[i].flags = 0;
|
||||
goto exit;
|
||||
}
|
||||
/* save to the driver level mapping table */
|
||||
rmi_smb->mapping_table[i].rmiaddr = rmiaddr;
|
||||
rmi_smb->mapping_table[i].readcount = bytecount;
|
||||
rmi_smb->mapping_table[i].flags = !isread ? RMI_SMB2_MAP_FLAGS_WE : 0;
|
||||
*commandcode = i;
|
||||
|
||||
exit:
|
||||
mutex_unlock(&rmi_smb->mappingtable_mutex);
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
static int rmi_smb_write_block(struct rmi_transport_dev *xport, u16 rmiaddr,
|
||||
const void *databuff, size_t len)
|
||||
{
|
||||
int retval = 0;
|
||||
u8 commandcode;
|
||||
struct rmi_smb_xport *rmi_smb =
|
||||
container_of(xport, struct rmi_smb_xport, xport);
|
||||
int cur_len = (int)len;
|
||||
|
||||
mutex_lock(&rmi_smb->page_mutex);
|
||||
|
||||
while (cur_len > 0) {
|
||||
/*
|
||||
* break into 32 bytes chunks to write get command code
|
||||
*/
|
||||
int block_len = min_t(int, len, SMB_MAX_COUNT);
|
||||
|
||||
retval = rmi_smb_get_command_code(xport, rmiaddr, block_len,
|
||||
false, &commandcode);
|
||||
if (retval < 0)
|
||||
goto exit;
|
||||
|
||||
retval = smb_block_write(xport, commandcode,
|
||||
databuff, block_len);
|
||||
if (retval < 0)
|
||||
goto exit;
|
||||
|
||||
/* prepare to write next block of bytes */
|
||||
cur_len -= SMB_MAX_COUNT;
|
||||
databuff += SMB_MAX_COUNT;
|
||||
rmiaddr += SMB_MAX_COUNT;
|
||||
}
|
||||
exit:
|
||||
mutex_unlock(&rmi_smb->page_mutex);
|
||||
return retval;
|
||||
}
|
||||
|
||||
/* SMB block read - wrapper over ic2_smb_read_block */
|
||||
static int smb_block_read(struct rmi_transport_dev *xport,
|
||||
u8 commandcode, void *buf, size_t len)
|
||||
{
|
||||
struct rmi_smb_xport *rmi_smb =
|
||||
container_of(xport, struct rmi_smb_xport, xport);
|
||||
struct i2c_client *client = rmi_smb->client;
|
||||
int retval;
|
||||
|
||||
retval = i2c_smbus_read_block_data(client, commandcode, buf);
|
||||
if (retval < 0)
|
||||
return retval;
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
static int rmi_smb_read_block(struct rmi_transport_dev *xport, u16 rmiaddr,
|
||||
void *databuff, size_t len)
|
||||
{
|
||||
struct rmi_smb_xport *rmi_smb =
|
||||
container_of(xport, struct rmi_smb_xport, xport);
|
||||
int retval;
|
||||
u8 commandcode;
|
||||
int cur_len = (int)len;
|
||||
|
||||
mutex_lock(&rmi_smb->page_mutex);
|
||||
memset(databuff, 0, len);
|
||||
|
||||
while (cur_len > 0) {
|
||||
/* break into 32 bytes chunks to write get command code */
|
||||
int block_len = min_t(int, cur_len, SMB_MAX_COUNT);
|
||||
|
||||
retval = rmi_smb_get_command_code(xport, rmiaddr, block_len,
|
||||
true, &commandcode);
|
||||
if (retval < 0)
|
||||
goto exit;
|
||||
|
||||
retval = smb_block_read(xport, commandcode,
|
||||
databuff, block_len);
|
||||
if (retval < 0)
|
||||
goto exit;
|
||||
|
||||
/* prepare to read next block of bytes */
|
||||
cur_len -= SMB_MAX_COUNT;
|
||||
databuff += SMB_MAX_COUNT;
|
||||
rmiaddr += SMB_MAX_COUNT;
|
||||
}
|
||||
|
||||
retval = 0;
|
||||
|
||||
exit:
|
||||
mutex_unlock(&rmi_smb->page_mutex);
|
||||
return retval;
|
||||
}
|
||||
|
||||
static void rmi_smb_clear_state(struct rmi_smb_xport *rmi_smb)
|
||||
{
|
||||
/* the mapping table has been flushed, discard the current one */
|
||||
mutex_lock(&rmi_smb->mappingtable_mutex);
|
||||
memset(rmi_smb->mapping_table, 0, sizeof(rmi_smb->mapping_table));
|
||||
mutex_unlock(&rmi_smb->mappingtable_mutex);
|
||||
}
|
||||
|
||||
static int rmi_smb_enable_smbus_mode(struct rmi_smb_xport *rmi_smb)
|
||||
{
|
||||
int retval;
|
||||
|
||||
/* we need to get the smbus version to activate the touchpad */
|
||||
retval = rmi_smb_get_version(rmi_smb);
|
||||
if (retval < 0)
|
||||
return retval;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int rmi_smb_reset(struct rmi_transport_dev *xport, u16 reset_addr)
|
||||
{
|
||||
struct rmi_smb_xport *rmi_smb =
|
||||
container_of(xport, struct rmi_smb_xport, xport);
|
||||
|
||||
rmi_smb_clear_state(rmi_smb);
|
||||
|
||||
/*
|
||||
* we do not call the actual reset command, it has to be handled in
|
||||
* PS/2 or there will be races between PS/2 and SMBus.
|
||||
* PS/2 should ensure that a psmouse_reset is called before
|
||||
* intializing the device and after it has been removed to be in a known
|
||||
* state.
|
||||
*/
|
||||
return rmi_smb_enable_smbus_mode(rmi_smb);
|
||||
}
|
||||
|
||||
static const struct rmi_transport_ops rmi_smb_ops = {
|
||||
.write_block = rmi_smb_write_block,
|
||||
.read_block = rmi_smb_read_block,
|
||||
.reset = rmi_smb_reset,
|
||||
};
|
||||
|
||||
static int rmi_smb_probe(struct i2c_client *client,
|
||||
const struct i2c_device_id *id)
|
||||
{
|
||||
struct rmi_device_platform_data *pdata = dev_get_platdata(&client->dev);
|
||||
struct rmi_smb_xport *rmi_smb;
|
||||
int retval;
|
||||
int smbus_version;
|
||||
|
||||
if (!i2c_check_functionality(client->adapter,
|
||||
I2C_FUNC_SMBUS_READ_BLOCK_DATA |
|
||||
I2C_FUNC_SMBUS_HOST_NOTIFY)) {
|
||||
dev_err(&client->dev,
|
||||
"adapter does not support required functionality.\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
if (client->irq <= 0) {
|
||||
dev_err(&client->dev, "no IRQ provided, giving up.\n");
|
||||
return client->irq ? client->irq : -ENODEV;
|
||||
}
|
||||
|
||||
rmi_smb = devm_kzalloc(&client->dev, sizeof(struct rmi_smb_xport),
|
||||
GFP_KERNEL);
|
||||
if (!rmi_smb)
|
||||
return -ENOMEM;
|
||||
|
||||
if (!pdata) {
|
||||
dev_err(&client->dev, "no platform data, aborting\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
rmi_dbg(RMI_DEBUG_XPORT, &client->dev, "Probing %s.\n",
|
||||
dev_name(&client->dev));
|
||||
|
||||
rmi_smb->client = client;
|
||||
mutex_init(&rmi_smb->page_mutex);
|
||||
mutex_init(&rmi_smb->mappingtable_mutex);
|
||||
|
||||
rmi_smb->xport.dev = &client->dev;
|
||||
rmi_smb->xport.pdata = *pdata;
|
||||
rmi_smb->xport.pdata.irq = client->irq;
|
||||
rmi_smb->xport.proto_name = "smb2";
|
||||
rmi_smb->xport.ops = &rmi_smb_ops;
|
||||
|
||||
retval = rmi_smb_get_version(rmi_smb);
|
||||
if (retval < 0)
|
||||
return retval;
|
||||
|
||||
smbus_version = retval;
|
||||
rmi_dbg(RMI_DEBUG_XPORT, &client->dev, "Smbus version is %d",
|
||||
smbus_version);
|
||||
|
||||
if (smbus_version != 2) {
|
||||
dev_err(&client->dev, "Unrecognized SMB version %d.\n",
|
||||
smbus_version);
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
i2c_set_clientdata(client, rmi_smb);
|
||||
|
||||
retval = rmi_register_transport_device(&rmi_smb->xport);
|
||||
if (retval) {
|
||||
dev_err(&client->dev, "Failed to register transport driver at 0x%.2X.\n",
|
||||
client->addr);
|
||||
i2c_set_clientdata(client, NULL);
|
||||
return retval;
|
||||
}
|
||||
|
||||
dev_info(&client->dev, "registered rmi smb driver at %#04x.\n",
|
||||
client->addr);
|
||||
return 0;
|
||||
|
||||
}
|
||||
|
||||
static int rmi_smb_remove(struct i2c_client *client)
|
||||
{
|
||||
struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
|
||||
|
||||
rmi_unregister_transport_device(&rmi_smb->xport);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __maybe_unused rmi_smb_suspend(struct device *dev)
|
||||
{
|
||||
struct i2c_client *client = to_i2c_client(dev);
|
||||
struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
|
||||
int ret;
|
||||
|
||||
ret = rmi_driver_suspend(rmi_smb->xport.rmi_dev, true);
|
||||
if (ret)
|
||||
dev_warn(dev, "Failed to suspend device: %d\n", ret);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int __maybe_unused rmi_smb_runtime_suspend(struct device *dev)
|
||||
{
|
||||
struct i2c_client *client = to_i2c_client(dev);
|
||||
struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
|
||||
int ret;
|
||||
|
||||
ret = rmi_driver_suspend(rmi_smb->xport.rmi_dev, false);
|
||||
if (ret)
|
||||
dev_warn(dev, "Failed to suspend device: %d\n", ret);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int __maybe_unused rmi_smb_resume(struct device *dev)
|
||||
{
|
||||
struct i2c_client *client = container_of(dev, struct i2c_client, dev);
|
||||
struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
|
||||
struct rmi_device *rmi_dev = rmi_smb->xport.rmi_dev;
|
||||
int ret;
|
||||
|
||||
rmi_smb_reset(&rmi_smb->xport, 0);
|
||||
|
||||
rmi_reset(rmi_dev);
|
||||
|
||||
ret = rmi_driver_resume(rmi_smb->xport.rmi_dev, true);
|
||||
if (ret)
|
||||
dev_warn(dev, "Failed to resume device: %d\n", ret);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __maybe_unused rmi_smb_runtime_resume(struct device *dev)
|
||||
{
|
||||
struct i2c_client *client = to_i2c_client(dev);
|
||||
struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
|
||||
int ret;
|
||||
|
||||
ret = rmi_driver_resume(rmi_smb->xport.rmi_dev, false);
|
||||
if (ret)
|
||||
dev_warn(dev, "Failed to resume device: %d\n", ret);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct dev_pm_ops rmi_smb_pm = {
|
||||
SET_SYSTEM_SLEEP_PM_OPS(rmi_smb_suspend, rmi_smb_resume)
|
||||
SET_RUNTIME_PM_OPS(rmi_smb_runtime_suspend, rmi_smb_runtime_resume,
|
||||
NULL)
|
||||
};
|
||||
|
||||
static const struct i2c_device_id rmi_id[] = {
|
||||
{ "rmi4_smbus", 0 },
|
||||
{ }
|
||||
};
|
||||
MODULE_DEVICE_TABLE(i2c, rmi_id);
|
||||
|
||||
static struct i2c_driver rmi_smb_driver = {
|
||||
.driver = {
|
||||
.name = "rmi4_smbus",
|
||||
.pm = &rmi_smb_pm,
|
||||
},
|
||||
.id_table = rmi_id,
|
||||
.probe = rmi_smb_probe,
|
||||
.remove = rmi_smb_remove,
|
||||
};
|
||||
|
||||
module_i2c_driver(rmi_smb_driver);
|
||||
|
||||
MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>");
|
||||
MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@redhat.com>");
|
||||
MODULE_DESCRIPTION("RMI4 SMBus driver");
|
||||
MODULE_LICENSE("GPL");
|
||||
Loading…
Reference in New Issue