667 lines
18 KiB
C
667 lines
18 KiB
C
|
/*
|
||
|
|
* ad525x_dpot: Driver for the Analog Devices AD525x digital potentiometers
|
||
|
|
* Copyright (c) 2009 Analog Devices, Inc.
|
||
|
|
* Author: Michael Hennerich <hennerich@blackfin.uclinux.org>
|
||
|
|
*
|
||
|
|
* DEVID #Wipers #Positions Resistor Options (kOhm)
|
||
|
|
* AD5258 1 64 1, 10, 50, 100
|
||
|
|
* AD5259 1 256 5, 10, 50, 100
|
||
|
|
* AD5251 2 64 1, 10, 50, 100
|
||
|
|
* AD5252 2 256 1, 10, 50, 100
|
||
|
|
* AD5255 3 512 25, 250
|
||
|
|
* AD5253 4 64 1, 10, 50, 100
|
||
|
|
* AD5254 4 256 1, 10, 50, 100
|
||
|
|
*
|
||
|
|
* See Documentation/misc-devices/ad525x_dpot.txt for more info.
|
||
|
|
*
|
||
|
|
* derived from ad5258.c
|
||
|
|
* Copyright (c) 2009 Cyber Switching, Inc.
|
||
|
|
* Author: Chris Verges <chrisv@cyberswitching.com>
|
||
|
|
*
|
||
|
|
* derived from ad5252.c
|
||
|
|
* Copyright (c) 2006 Michael Hennerich <hennerich@blackfin.uclinux.org>
|
||
|
|
*
|
||
|
|
* Licensed under the GPL-2 or later.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <linux/module.h>
|
||
|
|
#include <linux/device.h>
|
||
|
|
#include <linux/kernel.h>
|
||
|
|
#include <linux/init.h>
|
||
|
|
#include <linux/slab.h>
|
||
|
|
#include <linux/i2c.h>
|
||
|
|
#include <linux/delay.h>
|
||
|
|
|
||
|
|
#define DRIVER_NAME "ad525x_dpot"
|
||
|
|
#define DRIVER_VERSION "0.1"
|
||
|
|
|
||
|
|
enum dpot_devid {
|
||
|
|
AD5258_ID,
|
||
|
|
AD5259_ID,
|
||
|
|
AD5251_ID,
|
||
|
|
AD5252_ID,
|
||
|
|
AD5253_ID,
|
||
|
|
AD5254_ID,
|
||
|
|
AD5255_ID,
|
||
|
|
};
|
||
|
|
|
||
|
|
#define AD5258_MAX_POSITION 64
|
||
|
|
#define AD5259_MAX_POSITION 256
|
||
|
|
#define AD5251_MAX_POSITION 64
|
||
|
|
#define AD5252_MAX_POSITION 256
|
||
|
|
#define AD5253_MAX_POSITION 64
|
||
|
|
#define AD5254_MAX_POSITION 256
|
||
|
|
#define AD5255_MAX_POSITION 512
|
||
|
|
|
||
|
|
#define AD525X_RDAC0 0
|
||
|
|
#define AD525X_RDAC1 1
|
||
|
|
#define AD525X_RDAC2 2
|
||
|
|
#define AD525X_RDAC3 3
|
||
|
|
|
||
|
|
#define AD525X_REG_TOL 0x18
|
||
|
|
#define AD525X_TOL_RDAC0 (AD525X_REG_TOL | AD525X_RDAC0)
|
||
|
|
#define AD525X_TOL_RDAC1 (AD525X_REG_TOL | AD525X_RDAC1)
|
||
|
|
#define AD525X_TOL_RDAC2 (AD525X_REG_TOL | AD525X_RDAC2)
|
||
|
|
#define AD525X_TOL_RDAC3 (AD525X_REG_TOL | AD525X_RDAC3)
|
||
|
|
|
||
|
|
/* RDAC-to-EEPROM Interface Commands */
|
||
|
|
#define AD525X_I2C_RDAC (0x00 << 5)
|
||
|
|
#define AD525X_I2C_EEPROM (0x01 << 5)
|
||
|
|
#define AD525X_I2C_CMD (0x80)
|
||
|
|
|
||
|
|
#define AD525X_DEC_ALL_6DB (AD525X_I2C_CMD | (0x4 << 3))
|
||
|
|
#define AD525X_INC_ALL_6DB (AD525X_I2C_CMD | (0x9 << 3))
|
||
|
|
#define AD525X_DEC_ALL (AD525X_I2C_CMD | (0x6 << 3))
|
||
|
|
#define AD525X_INC_ALL (AD525X_I2C_CMD | (0xB << 3))
|
||
|
|
|
||
|
|
static s32 ad525x_read(struct i2c_client *client, u8 reg);
|
||
|
|
static s32 ad525x_write(struct i2c_client *client, u8 reg, u8 value);
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Client data (each client gets its own)
|
||
|
|
*/
|
||
|
|
|
||
|
|
struct dpot_data {
|
||
|
|
struct mutex update_lock;
|
||
|
|
unsigned rdac_mask;
|
||
|
|
unsigned max_pos;
|
||
|
|
unsigned devid;
|
||
|
|
};
|
||
|
|
|
||
|
|
/* sysfs functions */
|
||
|
|
|
||
|
|
static ssize_t sysfs_show_reg(struct device *dev,
|
||
|
|
struct device_attribute *attr, char *buf, u32 reg)
|
||
|
|
{
|
||
|
|
struct i2c_client *client = to_i2c_client(dev);
|
||
|
|
struct dpot_data *data = i2c_get_clientdata(client);
|
||
|
|
s32 value;
|
||
|
|
|
||
|
|
mutex_lock(&data->update_lock);
|
||
|
|
value = ad525x_read(client, reg);
|
||
|
|
mutex_unlock(&data->update_lock);
|
||
|
|
|
||
|
|
if (value < 0)
|
||
|
|
return -EINVAL;
|
||
|
|
/*
|
||
|
|
* Let someone else deal with converting this ...
|
||
|
|
* the tolerance is a two-byte value where the MSB
|
||
|
|
* is a sign + integer value, and the LSB is a
|
||
|
|
* decimal value. See page 18 of the AD5258
|
||
|
|
* datasheet (Rev. A) for more details.
|
||
|
|
*/
|
||
|
|
|
||
|
|
if (reg & AD525X_REG_TOL)
|
||
|
|
return sprintf(buf, "0x%04x\n", value & 0xFFFF);
|
||
|
|
else
|
||
|
|
return sprintf(buf, "%u\n", value & data->rdac_mask);
|
||
|
|
}
|
||
|
|
|
||
|
|
static ssize_t sysfs_set_reg(struct device *dev,
|
||
|
|
struct device_attribute *attr,
|
||
|
|
const char *buf, size_t count, u32 reg)
|
||
|
|
{
|
||
|
|
struct i2c_client *client = to_i2c_client(dev);
|
||
|
|
struct dpot_data *data = i2c_get_clientdata(client);
|
||
|
|
unsigned long value;
|
||
|
|
int err;
|
||
|
|
|
||
|
|
err = strict_strtoul(buf, 10, &value);
|
||
|
|
if (err)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
if (value > data->rdac_mask)
|
||
|
|
value = data->rdac_mask;
|
||
|
|
|
||
|
|
mutex_lock(&data->update_lock);
|
||
|
|
ad525x_write(client, reg, value);
|
||
|
|
if (reg & AD525X_I2C_EEPROM)
|
||
|
|
msleep(26); /* Sleep while the EEPROM updates */
|
||
|
|
mutex_unlock(&data->update_lock);
|
||
|
|
|
||
|
|
return count;
|
||
|
|
}
|
||
|
|
|
||
|
|
static ssize_t sysfs_do_cmd(struct device *dev,
|
||
|
|
struct device_attribute *attr,
|
||
|
|
const char *buf, size_t count, u32 reg)
|
||
|
|
{
|
||
|
|
struct i2c_client *client = to_i2c_client(dev);
|
||
|
|
struct dpot_data *data = i2c_get_clientdata(client);
|
||
|
|
|
||
|
|
mutex_lock(&data->update_lock);
|
||
|
|
ad525x_write(client, reg, 0);
|
||
|
|
mutex_unlock(&data->update_lock);
|
||
|
|
|
||
|
|
return count;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* ------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
static ssize_t show_rdac0(struct device *dev,
|
||
|
|
struct device_attribute *attr, char *buf)
|
||
|
|
{
|
||
|
|
return sysfs_show_reg(dev, attr, buf, AD525X_I2C_RDAC | AD525X_RDAC0);
|
||
|
|
}
|
||
|
|
|
||
|
|
static ssize_t set_rdac0(struct device *dev,
|
||
|
|
struct device_attribute *attr,
|
||
|
|
const char *buf, size_t count)
|
||
|
|
{
|
||
|
|
return sysfs_set_reg(dev, attr, buf, count,
|
||
|
|
AD525X_I2C_RDAC | AD525X_RDAC0);
|
||
|
|
}
|
||
|
|
|
||
|
|
static DEVICE_ATTR(rdac0, S_IWUSR | S_IRUGO, show_rdac0, set_rdac0);
|
||
|
|
|
||
|
|
static ssize_t show_eeprom0(struct device *dev,
|
||
|
|
struct device_attribute *attr, char *buf)
|
||
|
|
{
|
||
|
|
return sysfs_show_reg(dev, attr, buf, AD525X_I2C_EEPROM | AD525X_RDAC0);
|
||
|
|
}
|
||
|
|
|
||
|
|
static ssize_t set_eeprom0(struct device *dev,
|
||
|
|
struct device_attribute *attr,
|
||
|
|
const char *buf, size_t count)
|
||
|
|
{
|
||
|
|
return sysfs_set_reg(dev, attr, buf, count,
|
||
|
|
AD525X_I2C_EEPROM | AD525X_RDAC0);
|
||
|
|
}
|
||
|
|
|
||
|
|
static DEVICE_ATTR(eeprom0, S_IWUSR | S_IRUGO, show_eeprom0, set_eeprom0);
|
||
|
|
|
||
|
|
static ssize_t show_tolerance0(struct device *dev,
|
||
|
|
struct device_attribute *attr, char *buf)
|
||
|
|
{
|
||
|
|
return sysfs_show_reg(dev, attr, buf,
|
||
|
|
AD525X_I2C_EEPROM | AD525X_TOL_RDAC0);
|
||
|
|
}
|
||
|
|
|
||
|
|
static DEVICE_ATTR(tolerance0, S_IRUGO, show_tolerance0, NULL);
|
||
|
|
|
||
|
|
/* ------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
static ssize_t show_rdac1(struct device *dev,
|
||
|
|
struct device_attribute *attr, char *buf)
|
||
|
|
{
|
||
|
|
return sysfs_show_reg(dev, attr, buf, AD525X_I2C_RDAC | AD525X_RDAC1);
|
||
|
|
}
|
||
|
|
|
||
|
|
static ssize_t set_rdac1(struct device *dev,
|
||
|
|
struct device_attribute *attr,
|
||
|
|
const char *buf, size_t count)
|
||
|
|
{
|
||
|
|
return sysfs_set_reg(dev, attr, buf, count,
|
||
|
|
AD525X_I2C_RDAC | AD525X_RDAC1);
|
||
|
|
}
|
||
|
|
|
||
|
|
static DEVICE_ATTR(rdac1, S_IWUSR | S_IRUGO, show_rdac1, set_rdac1);
|
||
|
|
|
||
|
|
static ssize_t show_eeprom1(struct device *dev,
|
||
|
|
struct device_attribute *attr, char *buf)
|
||
|
|
{
|
||
|
|
return sysfs_show_reg(dev, attr, buf, AD525X_I2C_EEPROM | AD525X_RDAC1);
|
||
|
|
}
|
||
|
|
|
||
|
|
static ssize_t set_eeprom1(struct device *dev,
|
||
|
|
struct device_attribute *attr,
|
||
|
|
const char *buf, size_t count)
|
||
|
|
{
|
||
|
|
return sysfs_set_reg(dev, attr, buf, count,
|
||
|
|
AD525X_I2C_EEPROM | AD525X_RDAC1);
|
||
|
|
}
|
||
|
|
|
||
|
|
static DEVICE_ATTR(eeprom1, S_IWUSR | S_IRUGO, show_eeprom1, set_eeprom1);
|
||
|
|
|
||
|
|
static ssize_t show_tolerance1(struct device *dev,
|
||
|
|
struct device_attribute *attr, char *buf)
|
||
|
|
{
|
||
|
|
return sysfs_show_reg(dev, attr, buf,
|
||
|
|
AD525X_I2C_EEPROM | AD525X_TOL_RDAC1);
|
||
|
|
}
|
||
|
|
|
||
|
|
static DEVICE_ATTR(tolerance1, S_IRUGO, show_tolerance1, NULL);
|
||
|
|
|
||
|
|
/* ------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
static ssize_t show_rdac2(struct device *dev,
|
||
|
|
struct device_attribute *attr, char *buf)
|
||
|
|
{
|
||
|
|
return sysfs_show_reg(dev, attr, buf, AD525X_I2C_RDAC | AD525X_RDAC2);
|
||
|
|
}
|
||
|
|
|
||
|
|
static ssize_t set_rdac2(struct device *dev,
|
||
|
|
struct device_attribute *attr,
|
||
|
|
const char *buf, size_t count)
|
||
|
|
{
|
||
|
|
return sysfs_set_reg(dev, attr, buf, count,
|
||
|
|
AD525X_I2C_RDAC | AD525X_RDAC2);
|
||
|
|
}
|
||
|
|
|
||
|
|
static DEVICE_ATTR(rdac2, S_IWUSR | S_IRUGO, show_rdac2, set_rdac2);
|
||
|
|
|
||
|
|
static ssize_t show_eeprom2(struct device *dev,
|
||
|
|
struct device_attribute *attr, char *buf)
|
||
|
|
{
|
||
|
|
return sysfs_show_reg(dev, attr, buf, AD525X_I2C_EEPROM | AD525X_RDAC2);
|
||
|
|
}
|
||
|
|
|
||
|
|
static ssize_t set_eeprom2(struct device *dev,
|
||
|
|
struct device_attribute *attr,
|
||
|
|
const char *buf, size_t count)
|
||
|
|
{
|
||
|
|
return sysfs_set_reg(dev, attr, buf, count,
|
||
|
|
AD525X_I2C_EEPROM | AD525X_RDAC2);
|
||
|
|
}
|
||
|
|
|
||
|
|
static DEVICE_ATTR(eeprom2, S_IWUSR | S_IRUGO, show_eeprom2, set_eeprom2);
|
||
|
|
|
||
|
|
static ssize_t show_tolerance2(struct device *dev,
|
||
|
|
struct device_attribute *attr, char *buf)
|
||
|
|
{
|
||
|
|
return sysfs_show_reg(dev, attr, buf,
|
||
|
|
AD525X_I2C_EEPROM | AD525X_TOL_RDAC2);
|
||
|
|
}
|
||
|
|
|
||
|
|
static DEVICE_ATTR(tolerance2, S_IRUGO, show_tolerance2, NULL);
|
||
|
|
|
||
|
|
/* ------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
static ssize_t show_rdac3(struct device *dev,
|
||
|
|
struct device_attribute *attr, char *buf)
|
||
|
|
{
|
||
|
|
return sysfs_show_reg(dev, attr, buf, AD525X_I2C_RDAC | AD525X_RDAC3);
|
||
|
|
}
|
||
|
|
|
||
|
|
static ssize_t set_rdac3(struct device *dev,
|
||
|
|
struct device_attribute *attr,
|
||
|
|
const char *buf, size_t count)
|
||
|
|
{
|
||
|
|
return sysfs_set_reg(dev, attr, buf, count,
|
||
|
|
AD525X_I2C_RDAC | AD525X_RDAC3);
|
||
|
|
}
|
||
|
|
|
||
|
|
static DEVICE_ATTR(rdac3, S_IWUSR | S_IRUGO, show_rdac3, set_rdac3);
|
||
|
|
|
||
|
|
static ssize_t show_eeprom3(struct device *dev,
|
||
|
|
struct device_attribute *attr, char *buf)
|
||
|
|
{
|
||
|
|
return sysfs_show_reg(dev, attr, buf, AD525X_I2C_EEPROM | AD525X_RDAC3);
|
||
|
|
}
|
||
|
|
|
||
|
|
static ssize_t set_eeprom3(struct device *dev,
|
||
|
|
struct device_attribute *attr,
|
||
|
|
const char *buf, size_t count)
|
||
|
|
{
|
||
|
|
return sysfs_set_reg(dev, attr, buf, count,
|
||
|
|
AD525X_I2C_EEPROM | AD525X_RDAC3);
|
||
|
|
}
|
||
|
|
|
||
|
|
static DEVICE_ATTR(eeprom3, S_IWUSR | S_IRUGO, show_eeprom3, set_eeprom3);
|
||
|
|
|
||
|
|
static ssize_t show_tolerance3(struct device *dev,
|
||
|
|
struct device_attribute *attr, char *buf)
|
||
|
|
{
|
||
|
|
return sysfs_show_reg(dev, attr, buf,
|
||
|
|
AD525X_I2C_EEPROM | AD525X_TOL_RDAC3);
|
||
|
|
}
|
||
|
|
|
||
|
|
static DEVICE_ATTR(tolerance3, S_IRUGO, show_tolerance3, NULL);
|
||
|
|
|
||
|
|
static struct attribute *ad525x_attributes_wipers[4][4] = {
|
||
|
|
{
|
||
|
|
&dev_attr_rdac0.attr,
|
||
|
|
&dev_attr_eeprom0.attr,
|
||
|
|
&dev_attr_tolerance0.attr,
|
||
|
|
NULL
|
||
|
|
}, {
|
||
|
|
&dev_attr_rdac1.attr,
|
||
|
|
&dev_attr_eeprom1.attr,
|
||
|
|
&dev_attr_tolerance1.attr,
|
||
|
|
NULL
|
||
|
|
}, {
|
||
|
|
&dev_attr_rdac2.attr,
|
||
|
|
&dev_attr_eeprom2.attr,
|
||
|
|
&dev_attr_tolerance2.attr,
|
||
|
|
NULL
|
||
|
|
}, {
|
||
|
|
&dev_attr_rdac3.attr,
|
||
|
|
&dev_attr_eeprom3.attr,
|
||
|
|
&dev_attr_tolerance3.attr,
|
||
|
|
NULL
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
static const struct attribute_group ad525x_group_wipers[] = {
|
||
|
|
{.attrs = ad525x_attributes_wipers[AD525X_RDAC0]},
|
||
|
|
{.attrs = ad525x_attributes_wipers[AD525X_RDAC1]},
|
||
|
|
{.attrs = ad525x_attributes_wipers[AD525X_RDAC2]},
|
||
|
|
{.attrs = ad525x_attributes_wipers[AD525X_RDAC3]},
|
||
|
|
};
|
||
|
|
|
||
|
|
/* ------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
static ssize_t set_inc_all(struct device *dev,
|
||
|
|
struct device_attribute *attr,
|
||
|
|
const char *buf, size_t count)
|
||
|
|
{
|
||
|
|
return sysfs_do_cmd(dev, attr, buf, count, AD525X_INC_ALL);
|
||
|
|
}
|
||
|
|
|
||
|
|
static DEVICE_ATTR(inc_all, S_IWUSR, NULL, set_inc_all);
|
||
|
|
|
||
|
|
static ssize_t set_dec_all(struct device *dev,
|
||
|
|
struct device_attribute *attr,
|
||
|
|
const char *buf, size_t count)
|
||
|
|
{
|
||
|
|
return sysfs_do_cmd(dev, attr, buf, count, AD525X_DEC_ALL);
|
||
|
|
}
|
||
|
|
|
||
|
|
static DEVICE_ATTR(dec_all, S_IWUSR, NULL, set_dec_all);
|
||
|
|
|
||
|
|
static ssize_t set_inc_all_6db(struct device *dev,
|
||
|
|
struct device_attribute *attr,
|
||
|
|
const char *buf, size_t count)
|
||
|
|
{
|
||
|
|
return sysfs_do_cmd(dev, attr, buf, count, AD525X_INC_ALL_6DB);
|
||
|
|
}
|
||
|
|
|
||
|
|
static DEVICE_ATTR(inc_all_6db, S_IWUSR, NULL, set_inc_all_6db);
|
||
|
|
|
||
|
|
static ssize_t set_dec_all_6db(struct device *dev,
|
||
|
|
struct device_attribute *attr,
|
||
|
|
const char *buf, size_t count)
|
||
|
|
{
|
||
|
|
return sysfs_do_cmd(dev, attr, buf, count, AD525X_DEC_ALL_6DB);
|
||
|
|
}
|
||
|
|
|
||
|
|
static DEVICE_ATTR(dec_all_6db, S_IWUSR, NULL, set_dec_all_6db);
|
||
|
|
|
||
|
|
static struct attribute *ad525x_attributes_commands[] = {
|
||
|
|
&dev_attr_inc_all.attr,
|
||
|
|
&dev_attr_dec_all.attr,
|
||
|
|
&dev_attr_inc_all_6db.attr,
|
||
|
|
&dev_attr_dec_all_6db.attr,
|
||
|
|
NULL
|
||
|
|
};
|
||
|
|
|
||
|
|
static const struct attribute_group ad525x_group_commands = {
|
||
|
|
.attrs = ad525x_attributes_commands,
|
||
|
|
};
|
||
|
|
|
||
|
|
/* ------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/* i2c device functions */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* ad525x_read - return the value contained in the specified register
|
||
|
|
* on the AD5258 device.
|
||
|
|
* @client: value returned from i2c_new_device()
|
||
|
|
* @reg: the register to read
|
||
|
|
*
|
||
|
|
* If the tolerance register is specified, 2 bytes are returned.
|
||
|
|
* Otherwise, 1 byte is returned. A negative value indicates an error
|
||
|
|
* occurred while reading the register.
|
||
|
|
*/
|
||
|
|
static s32 ad525x_read(struct i2c_client *client, u8 reg)
|
||
|
|
{
|
||
|
|
struct dpot_data *data = i2c_get_clientdata(client);
|
||
|
|
|
||
|
|
if ((reg & AD525X_REG_TOL) || (data->max_pos > 256))
|
||
|
|
return i2c_smbus_read_word_data(client, (reg & 0xF8) |
|
||
|
|
((reg & 0x7) << 1));
|
||
|
|
else
|
||
|
|
return i2c_smbus_read_byte_data(client, reg);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* ad525x_write - store the given value in the specified register on
|
||
|
|
* the AD5258 device.
|
||
|
|
* @client: value returned from i2c_new_device()
|
||
|
|
* @reg: the register to write
|
||
|
|
* @value: the byte to store in the register
|
||
|
|
*
|
||
|
|
* For certain instructions that do not require a data byte, "NULL"
|
||
|
|
* should be specified for the "value" parameter. These instructions
|
||
|
|
* include NOP, RESTORE_FROM_EEPROM, and STORE_TO_EEPROM.
|
||
|
|
*
|
||
|
|
* A negative return value indicates an error occurred while reading
|
||
|
|
* the register.
|
||
|
|
*/
|
||
|
|
static s32 ad525x_write(struct i2c_client *client, u8 reg, u8 value)
|
||
|
|
{
|
||
|
|
struct dpot_data *data = i2c_get_clientdata(client);
|
||
|
|
|
||
|
|
/* Only write the instruction byte for certain commands */
|
||
|
|
if (reg & AD525X_I2C_CMD)
|
||
|
|
return i2c_smbus_write_byte(client, reg);
|
||
|
|
|
||
|
|
if (data->max_pos > 256)
|
||
|
|
return i2c_smbus_write_word_data(client, (reg & 0xF8) |
|
||
|
|
((reg & 0x7) << 1), value);
|
||
|
|
else
|
||
|
|
/* All other registers require instruction + data bytes */
|
||
|
|
return i2c_smbus_write_byte_data(client, reg, value);
|
||
|
|
}
|
||
|
|
|
||
|
|
static int ad525x_probe(struct i2c_client *client,
|
||
|
|
const struct i2c_device_id *id)
|
||
|
|
{
|
||
|
|
struct device *dev = &client->dev;
|
||
|
|
struct dpot_data *data;
|
||
|
|
int err = 0;
|
||
|
|
|
||
|
|
dev_dbg(dev, "%s\n", __func__);
|
||
|
|
|
||
|
|
if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE)) {
|
||
|
|
dev_err(dev, "missing I2C functionality for this driver\n");
|
||
|
|
goto exit;
|
||
|
|
}
|
||
|
|
|
||
|
|
data = kzalloc(sizeof(struct dpot_data), GFP_KERNEL);
|
||
|
|
if (!data) {
|
||
|
|
err = -ENOMEM;
|
||
|
|
goto exit;
|
||
|
|
}
|
||
|
|
|
||
|
|
i2c_set_clientdata(client, data);
|
||
|
|
mutex_init(&data->update_lock);
|
||
|
|
|
||
|
|
switch (id->driver_data) {
|
||
|
|
case AD5258_ID:
|
||
|
|
data->max_pos = AD5258_MAX_POSITION;
|
||
|
|
err = sysfs_create_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC0]);
|
||
|
|
break;
|
||
|
|
case AD5259_ID:
|
||
|
|
data->max_pos = AD5259_MAX_POSITION;
|
||
|
|
err = sysfs_create_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC0]);
|
||
|
|
break;
|
||
|
|
case AD5251_ID:
|
||
|
|
data->max_pos = AD5251_MAX_POSITION;
|
||
|
|
err = sysfs_create_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC1]);
|
||
|
|
err |= sysfs_create_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC3]);
|
||
|
|
err |= sysfs_create_group(&dev->kobj, &ad525x_group_commands);
|
||
|
|
break;
|
||
|
|
case AD5252_ID:
|
||
|
|
data->max_pos = AD5252_MAX_POSITION;
|
||
|
|
err = sysfs_create_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC1]);
|
||
|
|
err |= sysfs_create_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC3]);
|
||
|
|
err |= sysfs_create_group(&dev->kobj, &ad525x_group_commands);
|
||
|
|
break;
|
||
|
|
case AD5253_ID:
|
||
|
|
data->max_pos = AD5253_MAX_POSITION;
|
||
|
|
err = sysfs_create_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC0]);
|
||
|
|
err |= sysfs_create_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC1]);
|
||
|
|
err |= sysfs_create_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC2]);
|
||
|
|
err |= sysfs_create_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC3]);
|
||
|
|
err |= sysfs_create_group(&dev->kobj, &ad525x_group_commands);
|
||
|
|
break;
|
||
|
|
case AD5254_ID:
|
||
|
|
data->max_pos = AD5254_MAX_POSITION;
|
||
|
|
err = sysfs_create_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC0]);
|
||
|
|
err |= sysfs_create_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC1]);
|
||
|
|
err |= sysfs_create_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC2]);
|
||
|
|
err |= sysfs_create_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC3]);
|
||
|
|
err |= sysfs_create_group(&dev->kobj, &ad525x_group_commands);
|
||
|
|
break;
|
||
|
|
case AD5255_ID:
|
||
|
|
data->max_pos = AD5255_MAX_POSITION;
|
||
|
|
err = sysfs_create_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC0]);
|
||
|
|
err |= sysfs_create_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC1]);
|
||
|
|
err |= sysfs_create_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC2]);
|
||
|
|
err |= sysfs_create_group(&dev->kobj, &ad525x_group_commands);
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
err = -ENODEV;
|
||
|
|
goto exit_free;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (err) {
|
||
|
|
dev_err(dev, "failed to register sysfs hooks\n");
|
||
|
|
goto exit_free;
|
||
|
|
}
|
||
|
|
|
||
|
|
data->devid = id->driver_data;
|
||
|
|
data->rdac_mask = data->max_pos - 1;
|
||
|
|
|
||
|
|
dev_info(dev, "%s %d-Position Digital Potentiometer registered\n",
|
||
|
|
id->name, data->max_pos);
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
exit_free:
|
||
|
|
kfree(data);
|
||
|
|
i2c_set_clientdata(client, NULL);
|
||
|
|
exit:
|
||
|
|
dev_err(dev, "failed to create client\n");
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int __devexit ad525x_remove(struct i2c_client *client)
|
||
|
|
{
|
||
|
|
struct dpot_data *data = i2c_get_clientdata(client);
|
||
|
|
struct device *dev = &client->dev;
|
||
|
|
|
||
|
|
switch (data->devid) {
|
||
|
|
case AD5258_ID:
|
||
|
|
case AD5259_ID:
|
||
|
|
sysfs_remove_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC0]);
|
||
|
|
break;
|
||
|
|
case AD5251_ID:
|
||
|
|
case AD5252_ID:
|
||
|
|
sysfs_remove_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC1]);
|
||
|
|
sysfs_remove_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC3]);
|
||
|
|
sysfs_remove_group(&dev->kobj, &ad525x_group_commands);
|
||
|
|
break;
|
||
|
|
case AD5253_ID:
|
||
|
|
case AD5254_ID:
|
||
|
|
sysfs_remove_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC0]);
|
||
|
|
sysfs_remove_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC1]);
|
||
|
|
sysfs_remove_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC2]);
|
||
|
|
sysfs_remove_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC3]);
|
||
|
|
sysfs_remove_group(&dev->kobj, &ad525x_group_commands);
|
||
|
|
break;
|
||
|
|
case AD5255_ID:
|
||
|
|
sysfs_remove_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC0]);
|
||
|
|
sysfs_remove_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC1]);
|
||
|
|
sysfs_remove_group(&dev->kobj,
|
||
|
|
&ad525x_group_wipers[AD525X_RDAC2]);
|
||
|
|
sysfs_remove_group(&dev->kobj, &ad525x_group_commands);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
i2c_set_clientdata(client, NULL);
|
||
|
|
kfree(data);
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static const struct i2c_device_id ad525x_idtable[] = {
|
||
|
|
{"ad5258", AD5258_ID},
|
||
|
|
{"ad5259", AD5259_ID},
|
||
|
|
{"ad5251", AD5251_ID},
|
||
|
|
{"ad5252", AD5252_ID},
|
||
|
|
{"ad5253", AD5253_ID},
|
||
|
|
{"ad5254", AD5254_ID},
|
||
|
|
{"ad5255", AD5255_ID},
|
||
|
|
{}
|
||
|
|
};
|
||
|
|
|
||
|
|
MODULE_DEVICE_TABLE(i2c, ad525x_idtable);
|
||
|
|
|
||
|
|
static struct i2c_driver ad525x_driver = {
|
||
|
|
.driver = {
|
||
|
|
.owner = THIS_MODULE,
|
||
|
|
.name = DRIVER_NAME,
|
||
|
|
},
|
||
|
|
.id_table = ad525x_idtable,
|
||
|
|
.probe = ad525x_probe,
|
||
|
|
.remove = __devexit_p(ad525x_remove),
|
||
|
|
};
|
||
|
|
|
||
|
|
static int __init ad525x_init(void)
|
||
|
|
{
|
||
|
|
return i2c_add_driver(&ad525x_driver);
|
||
|
|
}
|
||
|
|
|
||
|
|
module_init(ad525x_init);
|
||
|
|
|
||
|
|
static void __exit ad525x_exit(void)
|
||
|
|
{
|
||
|
|
i2c_del_driver(&ad525x_driver);
|
||
|
|
}
|
||
|
|
|
||
|
|
module_exit(ad525x_exit);
|
||
|
|
|
||
|
|
MODULE_AUTHOR("Chris Verges <chrisv@cyberswitching.com>, "
|
||
|
|
"Michael Hennerich <hennerich@blackfin.uclinux.org>, ");
|
||
|
|
MODULE_DESCRIPTION("AD5258/9 digital potentiometer driver");
|
||
|
|
MODULE_LICENSE("GPL");
|
||
|
|
MODULE_VERSION(DRIVER_VERSION);
|