mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-25 02:09:42 +00:00
![Wolfram Sang](/assets/img/avatar_default.png)
A platform_driver does not need to set an owner, it will be populated by the driver core. Signed-off-by: Wolfram Sang <wsa@the-dreams.de>
303 lines
7.2 KiB
C
303 lines
7.2 KiB
C
/*
|
|
* CBUS I2C driver for Nokia Internet Tablets.
|
|
*
|
|
* Copyright (C) 2004-2010 Nokia Corporation
|
|
*
|
|
* Based on code written by Juha Yrjölä, David Weinehall, Mikko Ylinen and
|
|
* Felipe Balbi. Converted to I2C driver by Aaro Koskinen.
|
|
*
|
|
* This file is subject to the terms and conditions of the GNU General
|
|
* Public License. See the file "COPYING" in the main directory of this
|
|
* archive for more details.
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#include <linux/io.h>
|
|
#include <linux/i2c.h>
|
|
#include <linux/gpio.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/of_gpio.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/platform_data/i2c-cbus-gpio.h>
|
|
|
|
/*
|
|
* Bit counts are derived from Nokia implementation. These should be checked
|
|
* if other CBUS implementations appear.
|
|
*/
|
|
#define CBUS_ADDR_BITS 3
|
|
#define CBUS_REG_BITS 5
|
|
|
|
struct cbus_host {
|
|
spinlock_t lock; /* host lock */
|
|
struct device *dev;
|
|
int clk_gpio;
|
|
int dat_gpio;
|
|
int sel_gpio;
|
|
};
|
|
|
|
/**
|
|
* cbus_send_bit - sends one bit over the bus
|
|
* @host: the host we're using
|
|
* @bit: one bit of information to send
|
|
*/
|
|
static void cbus_send_bit(struct cbus_host *host, unsigned bit)
|
|
{
|
|
gpio_set_value(host->dat_gpio, bit ? 1 : 0);
|
|
gpio_set_value(host->clk_gpio, 1);
|
|
gpio_set_value(host->clk_gpio, 0);
|
|
}
|
|
|
|
/**
|
|
* cbus_send_data - sends @len amount of data over the bus
|
|
* @host: the host we're using
|
|
* @data: the data to send
|
|
* @len: size of the transfer
|
|
*/
|
|
static void cbus_send_data(struct cbus_host *host, unsigned data, unsigned len)
|
|
{
|
|
int i;
|
|
|
|
for (i = len; i > 0; i--)
|
|
cbus_send_bit(host, data & (1 << (i - 1)));
|
|
}
|
|
|
|
/**
|
|
* cbus_receive_bit - receives one bit from the bus
|
|
* @host: the host we're using
|
|
*/
|
|
static int cbus_receive_bit(struct cbus_host *host)
|
|
{
|
|
int ret;
|
|
|
|
gpio_set_value(host->clk_gpio, 1);
|
|
ret = gpio_get_value(host->dat_gpio);
|
|
gpio_set_value(host->clk_gpio, 0);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* cbus_receive_word - receives 16-bit word from the bus
|
|
* @host: the host we're using
|
|
*/
|
|
static int cbus_receive_word(struct cbus_host *host)
|
|
{
|
|
int ret = 0;
|
|
int i;
|
|
|
|
for (i = 16; i > 0; i--) {
|
|
int bit = cbus_receive_bit(host);
|
|
|
|
if (bit < 0)
|
|
return bit;
|
|
|
|
if (bit)
|
|
ret |= 1 << (i - 1);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* cbus_transfer - transfers data over the bus
|
|
* @host: the host we're using
|
|
* @rw: read/write flag
|
|
* @dev: device address
|
|
* @reg: register address
|
|
* @data: if @rw == I2C_SBUS_WRITE data to send otherwise 0
|
|
*/
|
|
static int cbus_transfer(struct cbus_host *host, char rw, unsigned dev,
|
|
unsigned reg, unsigned data)
|
|
{
|
|
unsigned long flags;
|
|
int ret;
|
|
|
|
/* We don't want interrupts disturbing our transfer */
|
|
spin_lock_irqsave(&host->lock, flags);
|
|
|
|
/* Reset state and start of transfer, SEL stays down during transfer */
|
|
gpio_set_value(host->sel_gpio, 0);
|
|
|
|
/* Set the DAT pin to output */
|
|
gpio_direction_output(host->dat_gpio, 1);
|
|
|
|
/* Send the device address */
|
|
cbus_send_data(host, dev, CBUS_ADDR_BITS);
|
|
|
|
/* Send the rw flag */
|
|
cbus_send_bit(host, rw == I2C_SMBUS_READ);
|
|
|
|
/* Send the register address */
|
|
cbus_send_data(host, reg, CBUS_REG_BITS);
|
|
|
|
if (rw == I2C_SMBUS_WRITE) {
|
|
cbus_send_data(host, data, 16);
|
|
ret = 0;
|
|
} else {
|
|
ret = gpio_direction_input(host->dat_gpio);
|
|
if (ret) {
|
|
dev_dbg(host->dev, "failed setting direction\n");
|
|
goto out;
|
|
}
|
|
gpio_set_value(host->clk_gpio, 1);
|
|
|
|
ret = cbus_receive_word(host);
|
|
if (ret < 0) {
|
|
dev_dbg(host->dev, "failed receiving data\n");
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
/* Indicate end of transfer, SEL goes up until next transfer */
|
|
gpio_set_value(host->sel_gpio, 1);
|
|
gpio_set_value(host->clk_gpio, 1);
|
|
gpio_set_value(host->clk_gpio, 0);
|
|
|
|
out:
|
|
spin_unlock_irqrestore(&host->lock, flags);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int cbus_i2c_smbus_xfer(struct i2c_adapter *adapter,
|
|
u16 addr,
|
|
unsigned short flags,
|
|
char read_write,
|
|
u8 command,
|
|
int size,
|
|
union i2c_smbus_data *data)
|
|
{
|
|
struct cbus_host *chost = i2c_get_adapdata(adapter);
|
|
int ret;
|
|
|
|
if (size != I2C_SMBUS_WORD_DATA)
|
|
return -EINVAL;
|
|
|
|
ret = cbus_transfer(chost, read_write == I2C_SMBUS_READ, addr,
|
|
command, data->word);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
if (read_write == I2C_SMBUS_READ)
|
|
data->word = ret;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static u32 cbus_i2c_func(struct i2c_adapter *adapter)
|
|
{
|
|
return I2C_FUNC_SMBUS_READ_WORD_DATA | I2C_FUNC_SMBUS_WRITE_WORD_DATA;
|
|
}
|
|
|
|
static const struct i2c_algorithm cbus_i2c_algo = {
|
|
.smbus_xfer = cbus_i2c_smbus_xfer,
|
|
.functionality = cbus_i2c_func,
|
|
};
|
|
|
|
static int cbus_i2c_remove(struct platform_device *pdev)
|
|
{
|
|
struct i2c_adapter *adapter = platform_get_drvdata(pdev);
|
|
|
|
i2c_del_adapter(adapter);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int cbus_i2c_probe(struct platform_device *pdev)
|
|
{
|
|
struct i2c_adapter *adapter;
|
|
struct cbus_host *chost;
|
|
int ret;
|
|
|
|
adapter = devm_kzalloc(&pdev->dev, sizeof(struct i2c_adapter),
|
|
GFP_KERNEL);
|
|
if (!adapter)
|
|
return -ENOMEM;
|
|
|
|
chost = devm_kzalloc(&pdev->dev, sizeof(*chost), GFP_KERNEL);
|
|
if (!chost)
|
|
return -ENOMEM;
|
|
|
|
if (pdev->dev.of_node) {
|
|
struct device_node *dnode = pdev->dev.of_node;
|
|
if (of_gpio_count(dnode) != 3)
|
|
return -ENODEV;
|
|
chost->clk_gpio = of_get_gpio(dnode, 0);
|
|
chost->dat_gpio = of_get_gpio(dnode, 1);
|
|
chost->sel_gpio = of_get_gpio(dnode, 2);
|
|
} else if (dev_get_platdata(&pdev->dev)) {
|
|
struct i2c_cbus_platform_data *pdata =
|
|
dev_get_platdata(&pdev->dev);
|
|
chost->clk_gpio = pdata->clk_gpio;
|
|
chost->dat_gpio = pdata->dat_gpio;
|
|
chost->sel_gpio = pdata->sel_gpio;
|
|
} else {
|
|
return -ENODEV;
|
|
}
|
|
|
|
adapter->owner = THIS_MODULE;
|
|
adapter->class = I2C_CLASS_HWMON;
|
|
adapter->dev.parent = &pdev->dev;
|
|
adapter->dev.of_node = pdev->dev.of_node;
|
|
adapter->nr = pdev->id;
|
|
adapter->timeout = HZ;
|
|
adapter->algo = &cbus_i2c_algo;
|
|
strlcpy(adapter->name, "CBUS I2C adapter", sizeof(adapter->name));
|
|
|
|
spin_lock_init(&chost->lock);
|
|
chost->dev = &pdev->dev;
|
|
|
|
ret = devm_gpio_request_one(&pdev->dev, chost->clk_gpio,
|
|
GPIOF_OUT_INIT_LOW, "CBUS clk");
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = devm_gpio_request_one(&pdev->dev, chost->dat_gpio, GPIOF_IN,
|
|
"CBUS data");
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = devm_gpio_request_one(&pdev->dev, chost->sel_gpio,
|
|
GPIOF_OUT_INIT_HIGH, "CBUS sel");
|
|
if (ret)
|
|
return ret;
|
|
|
|
i2c_set_adapdata(adapter, chost);
|
|
platform_set_drvdata(pdev, adapter);
|
|
|
|
return i2c_add_numbered_adapter(adapter);
|
|
}
|
|
|
|
#if defined(CONFIG_OF)
|
|
static const struct of_device_id i2c_cbus_dt_ids[] = {
|
|
{ .compatible = "i2c-cbus-gpio", },
|
|
{ }
|
|
};
|
|
MODULE_DEVICE_TABLE(of, i2c_cbus_dt_ids);
|
|
#endif
|
|
|
|
static struct platform_driver cbus_i2c_driver = {
|
|
.probe = cbus_i2c_probe,
|
|
.remove = cbus_i2c_remove,
|
|
.driver = {
|
|
.name = "i2c-cbus-gpio",
|
|
.of_match_table = of_match_ptr(i2c_cbus_dt_ids),
|
|
},
|
|
};
|
|
module_platform_driver(cbus_i2c_driver);
|
|
|
|
MODULE_ALIAS("platform:i2c-cbus-gpio");
|
|
MODULE_DESCRIPTION("CBUS I2C driver");
|
|
MODULE_AUTHOR("Juha Yrjölä");
|
|
MODULE_AUTHOR("David Weinehall");
|
|
MODULE_AUTHOR("Mikko Ylinen");
|
|
MODULE_AUTHOR("Felipe Balbi");
|
|
MODULE_AUTHOR("Aaro Koskinen <aaro.koskinen@iki.fi>");
|
|
MODULE_LICENSE("GPL");
|