#include <linux/ncs8801s.h>
|
|
#define NCS8801S_NAME ("ncs8801s")
|
#define NCS8801S_MATCH_DTS_EN 1
|
|
#ifndef Debug_message
|
#define Debug_message 0
|
#endif
|
|
#if Debug_message
|
#define printinfo(fmt, ...) printk("%s-<%d>:" fmt, __func__, __LINE__, ##__VA_ARGS__);
|
#else
|
#define printinfo(fmt, ...)
|
#endif
|
|
#if Debug_message
|
static int i2c_read_byte(unsigned char address, unsigned char offset, unsigned char byteno, unsigned char *p_data);
|
#endif
|
|
struct ncs8801s_config ncs8801s_config_info = {
|
.twi_id = 5,
|
};
|
|
static int i2c_write_byte(unsigned char address, unsigned char offset, unsigned char byteno, unsigned char p_data)
|
{
|
int ret;
|
struct i2c_adapter *adap = NULL;
|
struct i2c_msg msg;
|
unsigned char data[256];
|
|
printinfo("address>>1 is 0x%x,,,offset is 0x%x\n", address>>1, offset);
|
if ((address >> 1) == ncs8801s_this_client->addr) {
|
printinfo("this adapter is ncs8801s first adapter\n");
|
adap = ncs8801s_this_client->adapter;
|
} else if ((ncs8801s_second_client != NULL) && ((address >> 1) == ncs8801s_second_client->addr)) {
|
printinfo("this adapter is ncs8801s second adapter\n");
|
adap = ncs8801s_second_client->adapter;
|
} else {
|
printinfo("this adapter is enter else\n");
|
if (ncs8801s_second_client != NULL) {
|
printinfo("second_client is not null,,,second_client->addr=0x%x\n", ncs8801s_second_client->addr);
|
} else {
|
printinfo("second_client is null !!!\n");
|
}
|
adap = ncs8801s_this_client->adapter;
|
}
|
|
data[0] = offset;
|
data[1] = p_data;
|
printinfo("p_data = 0x%2x\n", p_data);
|
|
msg.addr = address >> 1;
|
msg.flags = 0;
|
msg.len = byteno + 1;
|
msg.buf = data;
|
|
ret = i2c_transfer(adap, &msg, 1);
|
|
if (ret >= 0) {
|
return 1;
|
} else {
|
printinfo("error! slave = 0x%x, addr = 0x%2x\n ", address >> 1, offset);
|
}
|
|
return 0;
|
}
|
|
#if Debug_message
|
static int i2c_read_byte(unsigned char address, unsigned char offset, unsigned char byteno, unsigned char *p_data)
|
{
|
unsigned char i;
|
int ret;
|
struct i2c_adapter *adap = NULL;
|
struct i2c_msg msg[2];
|
unsigned char data[256];
|
|
printinfo("address >> 1 is 0x%x,,,offset is 0x%x\n", address >> 1, offset);
|
if ((address >> 1) == ncs8801s_this_client->addr) {
|
printinfo("this adapter is ncs8801s first adapter\n");
|
adap = ncs8801s_this_client->adapter;
|
} else if ((ncs8801s_second_client != NULL) && ((address >> 1) == ncs8801s_second_client->addr)) {
|
printinfo("this adapter is ncs8801s second adapter\n");
|
adap = ncs8801s_second_client->adapter;
|
} else {
|
printinfo("this adapter is enter else\n");
|
if (ncs8801s_second_client != NULL) {
|
printinfo("second_client is not null,,,second_client->addr=0x%x\n", ncs8801s_second_client->addr);
|
} else {
|
printinfo("second_client is null !!!\n");
|
}
|
adap = ncs8801s_this_client->adapter;
|
}
|
data[0] = offset;
|
|
/*
|
* Send out the register address...
|
*/
|
msg[0].addr = address >> 1;
|
msg[0].flags = 0;
|
msg[0].len = 1;
|
msg[0].buf = &data[0];
|
/*
|
* ...then read back the result.
|
*/
|
msg[1].addr = address >> 1;
|
msg[1].flags = I2C_M_RD;
|
msg[1].len = byteno;
|
msg[1].buf = &data[1];
|
|
ret = i2c_transfer(adap, msg, 2);
|
if (ret >= 0) {
|
if (byteno > 1) {
|
for (i = 0; i < byteno - 1; i++) {
|
p_data[i] = data[i+1];
|
}
|
} else {
|
p_data[0] = data[1];
|
printinfo("p_data = 0x%2x\n", *p_data);
|
}
|
return 1;
|
} else {
|
printinfo("error! slave = 0x%x, addr = 0x%2x\n", address >> 1, offset);
|
}
|
return 0;
|
}
|
#endif
|
|
static const struct i2c_device_id ncs8801s_id[] = {
|
{"ncs8801s_0", 0},
|
{"ncs8801s_1", 1},
|
{},
|
};
|
MODULE_DEVICE_TABLE(i2c, ncs8801s_id);
|
|
#if NCS8801S_MATCH_DTS_EN
|
static struct of_device_id ncs8801s_dt_ids[] = {
|
{.compatible = "allwinner,ncs8801s_two",},
|
{},
|
};
|
MODULE_DEVICE_TABLE(of, ncs8801s_dt_ids);
|
#endif
|
|
/*******************************************************
|
Function:
|
I2c probe.
|
Input:
|
client: i2c device struct.
|
id: device id.
|
Output:
|
Executive outcomes.
|
0: succeed.
|
*******************************************************/
|
static int ncs8801s_probe(struct i2c_client *client, const struct i2c_device_id *id)
|
{
|
int err;
|
#if Debug_message
|
unsigned char buffer;
|
unsigned char i = 0;
|
#endif
|
|
printinfo("probe ok,,,,enter,,,,,\n");
|
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
|
err = -ENODEV;
|
return err;
|
}
|
|
ncs8801s_config_info.ncs8801s_power_ldo = regulator_get(&client->dev, "ncs8801s");
|
if (client->addr == 0x70) {
|
ncs8801s_this_client = client;
|
printinfo("probe ok=first client=this_client==>0x%x\n", client->addr);
|
}
|
|
if (client->addr == 0x75) {
|
ncs8801s_second_client = client;
|
printinfo("probe ok=second client=this_client==>0x%x\n", client->addr);
|
}
|
|
if (ncs8801s_second_client) {
|
i2c_write_byte(0xe0, 0x0f, 1, 0x01);
|
i2c_write_byte(0xe0, 0x00, 1, 0x00);
|
i2c_write_byte(0xe0, 0x02, 1, 0x07);
|
i2c_write_byte(0xe0, 0x03, 1, 0x03);
|
i2c_write_byte(0xe0, 0x07, 1, 0xc2);
|
i2c_write_byte(0xe0, 0x09, 1, 0x01);
|
i2c_write_byte(0xe0, 0x0b, 1, 0x00);
|
i2c_write_byte(0xe0, 0x60, 1, 0x00);
|
i2c_write_byte(0xe0, 0x70, 1, 0x00);
|
i2c_write_byte(0xe0, 0x71, 1, 0x01);
|
i2c_write_byte(0xe0, 0x73, 1, 0x80);
|
i2c_write_byte(0xe0, 0x74, 1, 0x20);
|
i2c_write_byte(0xea, 0x00, 1, 0xb0);
|
i2c_write_byte(0xea, 0x84, 1, 0x10);
|
i2c_write_byte(0xea, 0x85, 1, 0x32);
|
i2c_write_byte(0xea, 0x01, 1, 0x00);
|
i2c_write_byte(0xea, 0x02, 1, 0x5c);
|
i2c_write_byte(0xea, 0x0b, 1, 0x47);
|
i2c_write_byte(0xea, 0x0e, 1, 0x06);
|
i2c_write_byte(0xea, 0x0f, 1, 0x06);
|
i2c_write_byte(0xea, 0x11, 1, 0x88);
|
i2c_write_byte(0xea, 0x22, 1, 0x04);
|
i2c_write_byte(0xea, 0x23, 1, 0xf8);
|
i2c_write_byte(0xea, 0x00, 1, 0xb1);
|
i2c_write_byte(0xe0, 0x0f, 1, 0x00);
|
|
#if Debug_message
|
for (i = 0; i < 48; i++) {
|
buffer = 0x00;
|
i2c_read_byte(0xe0, 0x00 + i, 1, &buffer);
|
printinfo("i2c_read_byte,,0x%x is buffer=0x%x\n", 0x00 + i, buffer);
|
}
|
#endif
|
}
|
return 0;
|
}
|
|
#if !NCS8801S_MATCH_DTS_EN
|
static int ncs8801s_detect(struct i2c_client *client, struct i2c_board_info *info)
|
{
|
struct i2c_adapter *adapter = client->adapter;
|
if (client == NULL || client->adapter == NULL) {
|
printinfo("ncs8801s detect client or client->adapter is NULL\n");
|
return -1;
|
}
|
|
printinfo("enter ncs8801s detect==>the adapter number is %d,,,,client->addr=%x\n", adapter->nr, client->addr);
|
|
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
|
printinfo("ncs8801s i2c_check_functionality is fail\n");
|
return -ENODEV;
|
}
|
|
if ((5 == adapter->nr) && (client->addr == 0x70)) {
|
printinfo("Detected chip ncs8801s first at adapter %d, address 0x%02x\n", i2c_adapter_id(adapter), client->addr);
|
strlcpy(info->type, "ncs8801s_0", I2C_NAME_SIZE);
|
} else if ((5 == adapter->nr) && (client->addr == 0x75)) {
|
printinfo("Detected chip ncs8801s second at adapter %d, address 0x%02x\n", i2c_adapter_id(adapter), client->addr);
|
strlcpy(info->type, "ncs8801s_1", I2C_NAME_SIZE);
|
} else {
|
printinfo("Detected chip ncs8801s first & second at adapter, address 0x70 & 0x75 fail\n");
|
return -ENODEV;
|
}
|
return 0;
|
}
|
#endif
|
|
static int ncs8801s_remove(struct i2c_client *client)
|
{
|
printk("it6807 remove:*************************\n");
|
return 0;
|
}
|
|
static int ncs8801s_pm_suspend(struct device *dev)
|
{
|
if (regulator_is_enabled(ncs8801s_config_info.ncs8801s_power_ldo)) {
|
regulator_disable(ncs8801s_config_info.ncs8801s_power_ldo);
|
}
|
|
if (regulator_is_enabled(ncs8801s_config_info.ncs8801s_vddio_ldo)) {
|
regulator_disable(ncs8801s_config_info.ncs8801s_vddio_ldo);
|
}
|
|
if (gpio_is_valid(ncs8801s_config_info.reset_gpio.gpio)) {
|
gpio_set_value(ncs8801s_config_info.reset_gpio.gpio, 0);
|
gpio_free(ncs8801s_config_info.reset_gpio.gpio);
|
}
|
|
return 0;
|
}
|
|
static int ncs8801s_pm_resume(struct device *dev)
|
{
|
int ret;
|
|
if (!IS_ERR(ncs8801s_config_info.ncs8801s_vddio_ldo)) {
|
printinfo("resume func set ncs8801s_vddio_ldo .\n");
|
regulator_set_voltage(ncs8801s_config_info.ncs8801s_vddio_ldo, (int)(ncs8801s_config_info.ncs8801s_vddio_vol)*1000, (int)(ncs8801s_config_info.ncs8801s_vddio_vol)*1000);
|
if (regulator_enable(ncs8801s_config_info.ncs8801s_vddio_ldo) != 0) {
|
pr_err("%s: enable ncs8801s_vddio_ldo error!\n", __func__);
|
return -1;
|
}
|
}
|
|
if (!IS_ERR(ncs8801s_config_info.ncs8801s_power_ldo)) {
|
printinfo("resume func set ncs8801s_power_ldo .\n");
|
regulator_set_voltage(ncs8801s_config_info.ncs8801s_power_ldo, (int)(ncs8801s_config_info.ncs8801s_power_vol)*1000, (int)(ncs8801s_config_info.ncs8801s_power_vol)*1000);
|
if (regulator_enable(ncs8801s_config_info.ncs8801s_power_ldo) != 0) {
|
pr_err("%s: enable ncs8801s_power_ldo error!\n", __func__);
|
return -1;
|
}
|
}
|
|
if (gpio_is_valid(ncs8801s_config_info.reset_gpio.gpio)) {
|
ret = gpio_request(ncs8801s_config_info.reset_gpio.gpio, NULL);
|
if (!ret) {
|
gpio_direction_output(ncs8801s_config_info.reset_gpio.gpio, 1);
|
gpio_set_value(ncs8801s_config_info.reset_gpio.gpio, 0);
|
mdelay(40);
|
gpio_set_value(ncs8801s_config_info.reset_gpio.gpio, 1);
|
}
|
}
|
|
if (ncs8801s_second_client) {
|
i2c_write_byte(0xe0, 0x0f, 1, 0x01);
|
i2c_write_byte(0xe0, 0x00, 1, 0x00);
|
i2c_write_byte(0xe0, 0x02, 1, 0x07);
|
i2c_write_byte(0xe0, 0x03, 1, 0x03);
|
i2c_write_byte(0xe0, 0x07, 1, 0xc2);
|
i2c_write_byte(0xe0, 0x09, 1, 0x01);
|
i2c_write_byte(0xe0, 0x0b, 1, 0x00);
|
i2c_write_byte(0xe0, 0x60, 1, 0x00);
|
i2c_write_byte(0xe0, 0x70, 1, 0x00);
|
i2c_write_byte(0xe0, 0x71, 1, 0x01);
|
i2c_write_byte(0xe0, 0x73, 1, 0x80);
|
i2c_write_byte(0xe0, 0x74, 1, 0x20);
|
i2c_write_byte(0xea, 0x00, 1, 0xb0);
|
i2c_write_byte(0xea, 0x84, 1, 0x10);
|
i2c_write_byte(0xea, 0x85, 1, 0x32);
|
i2c_write_byte(0xea, 0x01, 1, 0x00);
|
i2c_write_byte(0xea, 0x02, 1, 0x5c);
|
i2c_write_byte(0xea, 0x0b, 1, 0x47);
|
i2c_write_byte(0xea, 0x0e, 1, 0x06);
|
i2c_write_byte(0xea, 0x0f, 1, 0x06);
|
i2c_write_byte(0xea, 0x11, 1, 0x88);
|
i2c_write_byte(0xea, 0x22, 1, 0x04);
|
i2c_write_byte(0xea, 0x23, 1, 0xf8);
|
i2c_write_byte(0xea, 0x00, 1, 0xb1);
|
i2c_write_byte(0xe0, 0x0f, 1, 0x00);
|
}
|
|
return 0;
|
}
|
|
static const unsigned short normal_i2c[] = {0x70, 0x75, I2C_CLIENT_END};
|
|
static struct dev_pm_ops ncs8801s_pm_ops = {
|
.suspend = ncs8801s_pm_suspend,
|
.resume = ncs8801s_pm_resume,
|
};
|
|
static struct i2c_driver ncs8801s_driver = {
|
.class = I2C_CLASS_HWMON,
|
.driver = {
|
.name = NCS8801S_NAME,
|
.owner = THIS_MODULE,
|
#if NCS8801S_MATCH_DTS_EN
|
.of_match_table = ncs8801s_dt_ids,
|
#endif
|
#ifndef CONFIG_HAS_EARLYSUSPEND
|
#if defined(CONFIG_PM)
|
.pm = &ncs8801s_pm_ops,
|
#endif
|
#endif
|
},
|
.probe = ncs8801s_probe,
|
.remove = ncs8801s_remove,
|
.id_table = ncs8801s_id,
|
#if !NCS8801S_MATCH_DTS_EN
|
.detect = ncs8801s_detect,
|
.address_list = normal_i2c,
|
#endif
|
};
|
|
static int script_ncs8801s_gpio_init(void)
|
{
|
int ret = -1;
|
struct device_node *np = NULL;
|
struct ncs8801s_config *data = container_of(&(ncs8801s_config_info.twi_id), struct ncs8801s_config, twi_id);
|
struct i2c_client *client_tmp = NULL;
|
struct platform_device *pdev = NULL;
|
|
np = data->node;
|
|
if (!np) {
|
np = of_find_node_by_name(NULL, "ncs8801s_two_1");
|
}
|
|
if (!np) {
|
pr_err("ERROR! get ncs8801s_para failed, func:%s, line:%d\n", __FUNCTION__, __LINE__);
|
return -1;
|
}
|
|
if (!of_device_is_available(np)) {
|
pr_err("%s: ncs8801s is not used\n", __func__);
|
return -1;
|
} else {
|
ncs8801s_config_info.ncs8801s_used = 1;
|
data->ncs8801s_used = ncs8801s_config_info.ncs8801s_used;
|
}
|
|
client_tmp = of_find_i2c_device_by_node(np);
|
if (client_tmp) {
|
data->dev = &client_tmp->dev;
|
} else {
|
pdev = of_find_device_by_node(np);
|
if (pdev) {
|
data->dev = &pdev->dev;
|
}
|
}
|
|
if (!data->dev) {
|
pr_err("get ncs8801s device_node fail\n");
|
return -1;
|
} else {
|
pr_err("get ncs8801s device_node success\n");
|
}
|
|
ret = of_property_read_u32(np, "ncs8801s_vddio_vol", &data->ncs8801s_vddio_vol);
|
if (ret) {
|
pr_err("get ncs8801s_vddio_vol is fail, %d\n", ret);
|
return -1;
|
}
|
ncs8801s_config_info.ncs8801s_vddio_vol = data->ncs8801s_vddio_vol;
|
|
ret = of_property_read_u32(np, "ncs8801s_power_vol", &data->ncs8801s_power_vol);
|
if (ret) {
|
pr_err("get ncs8801s_power_vol is fail, %d\n", ret);
|
return -1;
|
}
|
ncs8801s_config_info.ncs8801s_power_vol = data->ncs8801s_power_vol;
|
|
|
data->reset_gpio.gpio = of_get_named_gpio_flags(np, "ncs8801s_two_reset", 0, (enum of_gpio_flags *)(&(data->reset_gpio)));
|
|
data->ncs8801s_vddio_ldo = regulator_get(data->dev, "ncs8801s_vddio");
|
if (!IS_ERR(data->ncs8801s_vddio_ldo)) {
|
printinfo("set ncs8801s_vddio_ldo .\n");
|
regulator_set_voltage(data->ncs8801s_vddio_ldo, (int)(data->ncs8801s_vddio_vol)*1000, (int)(data->ncs8801s_vddio_vol)*1000);
|
if (regulator_enable(data->ncs8801s_vddio_ldo) != 0) {
|
pr_err("%s: enable ncs8801s_vddio_ldo error!\n", __func__);
|
goto devicetree_err;
|
}
|
|
}
|
|
data->ncs8801s_power_ldo = regulator_get(data->dev, "ncs8801s");
|
if (!IS_ERR(data->ncs8801s_power_ldo)) {
|
printinfo("set ncs8801s_power_ldo .\n");
|
regulator_set_voltage(data->ncs8801s_power_ldo, (int)(data->ncs8801s_power_vol)*1000, (int)(data->ncs8801s_power_vol)*1000);
|
if (regulator_enable(data->ncs8801s_power_ldo) != 0) {
|
pr_err("%s: enable ncs8801s_power_ldo error!\n", __func__);
|
goto devicetree_err;
|
}
|
|
}
|
|
if (!gpio_is_valid(data->reset_gpio.gpio)) {
|
pr_err("%s: ncs8801s_reset_gpio is invalid.\n", __func__);
|
goto devicetree_err;
|
} else {
|
pr_err("%s: ncs8801s_reset_gpio success. \n", __func__);
|
if (0 != gpio_request(data->reset_gpio.gpio, NULL)) {
|
printk("reset_gpio_request is failed\n");
|
goto devicetree_err;
|
}
|
|
if (0 != gpio_direction_output(data->reset_gpio.gpio, 1)) {
|
printk("ncs8801s_reset_gpio set err!\n");
|
goto devicetree_err;
|
}
|
|
gpio_set_value(data->reset_gpio.gpio, 0);
|
mdelay(40);
|
gpio_set_value(data->reset_gpio.gpio, 1);
|
ncs8801s_config_info.reset_gpio = data->reset_gpio;
|
}
|
return 1;
|
|
devicetree_err:
|
if (regulator_is_enabled(data->ncs8801s_power_ldo)) {
|
regulator_disable(data->ncs8801s_power_ldo);
|
}
|
|
if (data->ncs8801s_power_ldo) {
|
regulator_put(data->ncs8801s_power_ldo);
|
data->ncs8801s_power_ldo = NULL;
|
}
|
|
if (regulator_is_enabled(data->ncs8801s_vddio_ldo)) {
|
regulator_disable(data->ncs8801s_vddio_ldo);
|
}
|
|
if (data->ncs8801s_vddio_ldo) {
|
regulator_put(data->ncs8801s_vddio_ldo);
|
data->ncs8801s_vddio_ldo = NULL;
|
}
|
|
if (gpio_is_valid(data->reset_gpio.gpio)) {
|
gpio_free(data->reset_gpio.gpio);
|
}
|
|
return -1;
|
}
|
|
|
/*******************************************************
|
Function:
|
Driver Install function.
|
Input:
|
None.
|
Output:
|
Executive Outcomes. 0---succeed.
|
********************************************************/
|
static int __init ncs8801s_init(void)
|
{
|
int ret = 0;
|
printk("ncs8801s init:*************************\n");
|
|
if (script_ncs8801s_gpio_init() > 0) {
|
ret = i2c_add_driver(&ncs8801s_driver);
|
if (ret != 0)
|
pr_err("Failed to register ncs8801s i2c driver : %d \n", ret);
|
}
|
|
return ret;
|
}
|
|
/*******************************************************
|
Function:
|
Driver uninstall function.
|
Input:
|
None.
|
Output:
|
Executive Outcomes. 0---succeed.
|
********************************************************/
|
static void __exit ncs8801s_exit(void)
|
{
|
if (regulator_is_enabled(ncs8801s_config_info.ncs8801s_power_ldo)) {
|
regulator_disable(ncs8801s_config_info.ncs8801s_power_ldo);
|
}
|
|
if (ncs8801s_config_info.ncs8801s_power_ldo) {
|
regulator_put(ncs8801s_config_info.ncs8801s_power_ldo);
|
ncs8801s_config_info.ncs8801s_power_ldo = NULL;
|
}
|
|
if (regulator_is_enabled(ncs8801s_config_info.ncs8801s_vddio_ldo)) {
|
regulator_disable(ncs8801s_config_info.ncs8801s_vddio_ldo);
|
}
|
|
if (ncs8801s_config_info.ncs8801s_vddio_ldo) {
|
regulator_put(ncs8801s_config_info.ncs8801s_vddio_ldo);
|
ncs8801s_config_info.ncs8801s_vddio_ldo = NULL;
|
}
|
|
if (gpio_is_valid(ncs8801s_config_info.reset_gpio.gpio)) {
|
gpio_free(ncs8801s_config_info.reset_gpio.gpio);
|
}
|
|
i2c_del_driver(&ncs8801s_driver);
|
printk("it6807 exit:*************************\n");
|
}
|
|
subsys_initcall_sync(ncs8801s_init);
|
module_exit(ncs8801s_exit);
|
|
MODULE_AUTHOR("<wanpeng@allwinnertech.com>");
|
MODULE_DESCRIPTION("ncs8801s Driver");
|
MODULE_LICENSE("GPL");
|
