mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-12 13:55:32 +00:00
![Jett.Zhou](/assets/img/avatar_default.png)
There are two banks in 88pm8607. One is the normal bank, and the other one is the test bank, it means it have the same register address in the normal bank and test bank seperately. For test bank register, it needs a special I2C sequence to acess as below, Touching to 0xFA address Touching to 0xFB address Touching to 0xFF address Accessing bank register Touching to 0xFE address Touching to 0xFC address This sequence can't be interrupted. It means that we can't use i2c_transfef() to implement touching 0xFA address. Otherwise, other i2c operation may be inserted into 0xFA and 0xFB operation since the lock of i2c_adapter is already released. So for test bank we implemented specific i2c read/write operation; Signed-off-by: Jett.Zhou <jtzhou@marvell.com> Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>
381 lines
8.8 KiB
C
381 lines
8.8 KiB
C
/*
|
|
* I2C driver for Marvell 88PM860x
|
|
*
|
|
* Copyright (C) 2009 Marvell International Ltd.
|
|
* Haojian Zhuang <haojian.zhuang@marvell.com>
|
|
*
|
|
* 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/module.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/i2c.h>
|
|
#include <linux/mfd/88pm860x.h>
|
|
#include <linux/slab.h>
|
|
|
|
static inline int pm860x_read_device(struct i2c_client *i2c,
|
|
int reg, int bytes, void *dest)
|
|
{
|
|
unsigned char data;
|
|
int ret;
|
|
|
|
data = (unsigned char)reg;
|
|
ret = i2c_master_send(i2c, &data, 1);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
ret = i2c_master_recv(i2c, dest, bytes);
|
|
if (ret < 0)
|
|
return ret;
|
|
return 0;
|
|
}
|
|
|
|
static inline int pm860x_write_device(struct i2c_client *i2c,
|
|
int reg, int bytes, void *src)
|
|
{
|
|
unsigned char buf[bytes + 1];
|
|
int ret;
|
|
|
|
buf[0] = (unsigned char)reg;
|
|
memcpy(&buf[1], src, bytes);
|
|
|
|
ret = i2c_master_send(i2c, buf, bytes + 1);
|
|
if (ret < 0)
|
|
return ret;
|
|
return 0;
|
|
}
|
|
|
|
int pm860x_reg_read(struct i2c_client *i2c, int reg)
|
|
{
|
|
struct pm860x_chip *chip = i2c_get_clientdata(i2c);
|
|
unsigned char data;
|
|
int ret;
|
|
|
|
mutex_lock(&chip->io_lock);
|
|
ret = pm860x_read_device(i2c, reg, 1, &data);
|
|
mutex_unlock(&chip->io_lock);
|
|
|
|
if (ret < 0)
|
|
return ret;
|
|
else
|
|
return (int)data;
|
|
}
|
|
EXPORT_SYMBOL(pm860x_reg_read);
|
|
|
|
int pm860x_reg_write(struct i2c_client *i2c, int reg,
|
|
unsigned char data)
|
|
{
|
|
struct pm860x_chip *chip = i2c_get_clientdata(i2c);
|
|
int ret;
|
|
|
|
mutex_lock(&chip->io_lock);
|
|
ret = pm860x_write_device(i2c, reg, 1, &data);
|
|
mutex_unlock(&chip->io_lock);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(pm860x_reg_write);
|
|
|
|
int pm860x_bulk_read(struct i2c_client *i2c, int reg,
|
|
int count, unsigned char *buf)
|
|
{
|
|
struct pm860x_chip *chip = i2c_get_clientdata(i2c);
|
|
int ret;
|
|
|
|
mutex_lock(&chip->io_lock);
|
|
ret = pm860x_read_device(i2c, reg, count, buf);
|
|
mutex_unlock(&chip->io_lock);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(pm860x_bulk_read);
|
|
|
|
int pm860x_bulk_write(struct i2c_client *i2c, int reg,
|
|
int count, unsigned char *buf)
|
|
{
|
|
struct pm860x_chip *chip = i2c_get_clientdata(i2c);
|
|
int ret;
|
|
|
|
mutex_lock(&chip->io_lock);
|
|
ret = pm860x_write_device(i2c, reg, count, buf);
|
|
mutex_unlock(&chip->io_lock);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(pm860x_bulk_write);
|
|
|
|
int pm860x_set_bits(struct i2c_client *i2c, int reg,
|
|
unsigned char mask, unsigned char data)
|
|
{
|
|
struct pm860x_chip *chip = i2c_get_clientdata(i2c);
|
|
unsigned char value;
|
|
int ret;
|
|
|
|
mutex_lock(&chip->io_lock);
|
|
ret = pm860x_read_device(i2c, reg, 1, &value);
|
|
if (ret < 0)
|
|
goto out;
|
|
value &= ~mask;
|
|
value |= data;
|
|
ret = pm860x_write_device(i2c, reg, 1, &value);
|
|
out:
|
|
mutex_unlock(&chip->io_lock);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(pm860x_set_bits);
|
|
|
|
static int read_device(struct i2c_client *i2c, int reg,
|
|
int bytes, void *dest)
|
|
{
|
|
unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX + 3];
|
|
unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX + 2];
|
|
struct i2c_adapter *adap = i2c->adapter;
|
|
struct i2c_msg msg[2] = {{i2c->addr, 0, 1, msgbuf0},
|
|
{i2c->addr, I2C_M_RD, 0, msgbuf1},
|
|
};
|
|
int num = 1, ret = 0;
|
|
|
|
if (dest == NULL)
|
|
return -EINVAL;
|
|
msgbuf0[0] = (unsigned char)reg; /* command */
|
|
msg[1].len = bytes;
|
|
|
|
/* if data needs to read back, num should be 2 */
|
|
if (bytes > 0)
|
|
num = 2;
|
|
ret = adap->algo->master_xfer(adap, msg, num);
|
|
memcpy(dest, msgbuf1, bytes);
|
|
if (ret < 0)
|
|
return ret;
|
|
return 0;
|
|
}
|
|
|
|
static int write_device(struct i2c_client *i2c, int reg,
|
|
int bytes, void *src)
|
|
{
|
|
unsigned char buf[bytes + 1];
|
|
struct i2c_adapter *adap = i2c->adapter;
|
|
struct i2c_msg msg;
|
|
int ret;
|
|
|
|
buf[0] = (unsigned char)reg;
|
|
memcpy(&buf[1], src, bytes);
|
|
msg.addr = i2c->addr;
|
|
msg.flags = 0;
|
|
msg.len = bytes + 1;
|
|
msg.buf = buf;
|
|
|
|
ret = adap->algo->master_xfer(adap, &msg, 1);
|
|
if (ret < 0)
|
|
return ret;
|
|
return 0;
|
|
}
|
|
|
|
int pm860x_page_reg_read(struct i2c_client *i2c, int reg)
|
|
{
|
|
unsigned char zero = 0;
|
|
unsigned char data;
|
|
int ret;
|
|
|
|
i2c_lock_adapter(i2c->adapter);
|
|
read_device(i2c, 0xFA, 0, &zero);
|
|
read_device(i2c, 0xFB, 0, &zero);
|
|
read_device(i2c, 0xFF, 0, &zero);
|
|
ret = read_device(i2c, reg, 1, &data);
|
|
if (ret >= 0)
|
|
ret = (int)data;
|
|
read_device(i2c, 0xFE, 0, &zero);
|
|
read_device(i2c, 0xFC, 0, &zero);
|
|
i2c_unlock_adapter(i2c->adapter);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(pm860x_page_reg_read);
|
|
|
|
int pm860x_page_reg_write(struct i2c_client *i2c, int reg,
|
|
unsigned char data)
|
|
{
|
|
unsigned char zero;
|
|
int ret;
|
|
|
|
i2c_lock_adapter(i2c->adapter);
|
|
read_device(i2c, 0xFA, 0, &zero);
|
|
read_device(i2c, 0xFB, 0, &zero);
|
|
read_device(i2c, 0xFF, 0, &zero);
|
|
ret = write_device(i2c, reg, 1, &data);
|
|
read_device(i2c, 0xFE, 0, &zero);
|
|
read_device(i2c, 0xFC, 0, &zero);
|
|
i2c_unlock_adapter(i2c->adapter);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(pm860x_page_reg_write);
|
|
|
|
int pm860x_page_bulk_read(struct i2c_client *i2c, int reg,
|
|
int count, unsigned char *buf)
|
|
{
|
|
unsigned char zero = 0;
|
|
int ret;
|
|
|
|
i2c_lock_adapter(i2c->adapter);
|
|
read_device(i2c, 0xfa, 0, &zero);
|
|
read_device(i2c, 0xfb, 0, &zero);
|
|
read_device(i2c, 0xff, 0, &zero);
|
|
ret = read_device(i2c, reg, count, buf);
|
|
read_device(i2c, 0xFE, 0, &zero);
|
|
read_device(i2c, 0xFC, 0, &zero);
|
|
i2c_unlock_adapter(i2c->adapter);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(pm860x_page_bulk_read);
|
|
|
|
int pm860x_page_bulk_write(struct i2c_client *i2c, int reg,
|
|
int count, unsigned char *buf)
|
|
{
|
|
unsigned char zero = 0;
|
|
int ret;
|
|
|
|
i2c_lock_adapter(i2c->adapter);
|
|
read_device(i2c, 0xFA, 0, &zero);
|
|
read_device(i2c, 0xFB, 0, &zero);
|
|
read_device(i2c, 0xFF, 0, &zero);
|
|
ret = write_device(i2c, reg, count, buf);
|
|
read_device(i2c, 0xFE, 0, &zero);
|
|
read_device(i2c, 0xFC, 0, &zero);
|
|
i2c_unlock_adapter(i2c->adapter);
|
|
i2c_unlock_adapter(i2c->adapter);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(pm860x_page_bulk_write);
|
|
|
|
int pm860x_page_set_bits(struct i2c_client *i2c, int reg,
|
|
unsigned char mask, unsigned char data)
|
|
{
|
|
unsigned char zero;
|
|
unsigned char value;
|
|
int ret;
|
|
|
|
i2c_lock_adapter(i2c->adapter);
|
|
read_device(i2c, 0xFA, 0, &zero);
|
|
read_device(i2c, 0xFB, 0, &zero);
|
|
read_device(i2c, 0xFF, 0, &zero);
|
|
ret = read_device(i2c, reg, 1, &value);
|
|
if (ret < 0)
|
|
goto out;
|
|
value &= ~mask;
|
|
value |= data;
|
|
ret = write_device(i2c, reg, 1, &value);
|
|
out:
|
|
read_device(i2c, 0xFE, 0, &zero);
|
|
read_device(i2c, 0xFC, 0, &zero);
|
|
i2c_unlock_adapter(i2c->adapter);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(pm860x_page_set_bits);
|
|
|
|
static const struct i2c_device_id pm860x_id_table[] = {
|
|
{ "88PM860x", 0 },
|
|
{}
|
|
};
|
|
MODULE_DEVICE_TABLE(i2c, pm860x_id_table);
|
|
|
|
static int verify_addr(struct i2c_client *i2c)
|
|
{
|
|
unsigned short addr_8607[] = {0x30, 0x34};
|
|
unsigned short addr_8606[] = {0x10, 0x11};
|
|
int size, i;
|
|
|
|
if (i2c == NULL)
|
|
return 0;
|
|
size = ARRAY_SIZE(addr_8606);
|
|
for (i = 0; i < size; i++) {
|
|
if (i2c->addr == *(addr_8606 + i))
|
|
return CHIP_PM8606;
|
|
}
|
|
size = ARRAY_SIZE(addr_8607);
|
|
for (i = 0; i < size; i++) {
|
|
if (i2c->addr == *(addr_8607 + i))
|
|
return CHIP_PM8607;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int __devinit pm860x_probe(struct i2c_client *client,
|
|
const struct i2c_device_id *id)
|
|
{
|
|
struct pm860x_platform_data *pdata = client->dev.platform_data;
|
|
struct pm860x_chip *chip;
|
|
|
|
if (!pdata) {
|
|
pr_info("No platform data in %s!\n", __func__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
chip = kzalloc(sizeof(struct pm860x_chip), GFP_KERNEL);
|
|
if (chip == NULL)
|
|
return -ENOMEM;
|
|
|
|
chip->id = verify_addr(client);
|
|
chip->client = client;
|
|
i2c_set_clientdata(client, chip);
|
|
chip->dev = &client->dev;
|
|
mutex_init(&chip->io_lock);
|
|
dev_set_drvdata(chip->dev, chip);
|
|
|
|
/*
|
|
* Both client and companion client shares same platform driver.
|
|
* Driver distinguishes them by pdata->companion_addr.
|
|
* pdata->companion_addr is only assigned if companion chip exists.
|
|
* At the same time, the companion_addr shouldn't equal to client
|
|
* address.
|
|
*/
|
|
if (pdata->companion_addr && (pdata->companion_addr != client->addr)) {
|
|
chip->companion_addr = pdata->companion_addr;
|
|
chip->companion = i2c_new_dummy(chip->client->adapter,
|
|
chip->companion_addr);
|
|
i2c_set_clientdata(chip->companion, chip);
|
|
}
|
|
|
|
pm860x_device_init(chip, pdata);
|
|
return 0;
|
|
}
|
|
|
|
static int __devexit pm860x_remove(struct i2c_client *client)
|
|
{
|
|
struct pm860x_chip *chip = i2c_get_clientdata(client);
|
|
|
|
pm860x_device_exit(chip);
|
|
i2c_unregister_device(chip->companion);
|
|
kfree(chip);
|
|
return 0;
|
|
}
|
|
|
|
static struct i2c_driver pm860x_driver = {
|
|
.driver = {
|
|
.name = "88PM860x",
|
|
.owner = THIS_MODULE,
|
|
},
|
|
.probe = pm860x_probe,
|
|
.remove = __devexit_p(pm860x_remove),
|
|
.id_table = pm860x_id_table,
|
|
};
|
|
|
|
static int __init pm860x_i2c_init(void)
|
|
{
|
|
int ret;
|
|
ret = i2c_add_driver(&pm860x_driver);
|
|
if (ret != 0)
|
|
pr_err("Failed to register 88PM860x I2C driver: %d\n", ret);
|
|
return ret;
|
|
}
|
|
subsys_initcall(pm860x_i2c_init);
|
|
|
|
static void __exit pm860x_i2c_exit(void)
|
|
{
|
|
i2c_del_driver(&pm860x_driver);
|
|
}
|
|
module_exit(pm860x_i2c_exit);
|
|
|
|
MODULE_DESCRIPTION("I2C Driver for Marvell 88PM860x");
|
|
MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
|
|
MODULE_LICENSE("GPL");
|