| /* |
| * 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); |
