drivers/misc/ad525x_dpot.c

   1 /*
   2  * ad525x_dpot: Driver for the Analog Devices digital potentiometers
   3  * Copyright (c) 2009-2010 Analog Devices, Inc.
   4  * Author: Michael Hennerich <hennerich@blackfin.uclinux.org>
   5  *
   6  * DEVID                #Wipers         #Positions      Resistor Options (kOhm)
   7  * AD5258               1               64              1, 10, 50, 100
   8  * AD5259               1               256             5, 10, 50, 100
   9  * AD5251               2               64              1, 10, 50, 100
  10  * AD5252               2               256             1, 10, 50, 100
  11  * AD5255               3               512             25, 250
  12  * AD5253               4               64              1, 10, 50, 100
  13  * AD5254               4               256             1, 10, 50, 100
  14  * AD5160               1               256             5, 10, 50, 100
  15  * AD5161               1               256             5, 10, 50, 100
  16  * AD5162               2               256             2.5, 10, 50, 100
  17  * AD5165               1               256             100
  18  * AD5200               1               256             10, 50
  19  * AD5201               1               33              10, 50
  20  * AD5203               4               64              10, 100
  21  * AD5204               4               256             10, 50, 100
  22  * AD5206               6               256             10, 50, 100
  23  * AD5207               2               256             10, 50, 100
  24  * AD5231               1               1024            10, 50, 100
  25  * AD5232               2               256             10, 50, 100
  26  * AD5233               4               64              10, 50, 100
  27  * AD5235               2               1024            25, 250
  28  * AD5260               1               256             20, 50, 200
  29  * AD5262               2               256             20, 50, 200
  30  * AD5263               4               256             20, 50, 200
  31  * AD5290               1               256             10, 50, 100
  32  * AD5291               1               256             20
  33  * AD5292               1               1024            20
  34  * AD5293               1               1024            20
  35  * AD7376               1               128             10, 50, 100, 1M
  36  * AD8400               1               256             1, 10, 50, 100
  37  * AD8402               2               256             1, 10, 50, 100
  38  * AD8403               4               256             1, 10, 50, 100
  39  * ADN2850              3               512             25, 250
  40  * AD5241               1               256             10, 100, 1M
  41  * AD5246               1               128             5, 10, 50, 100
  42  * AD5247               1               128             5, 10, 50, 100
  43  * AD5245               1               256             5, 10, 50, 100
  44  * AD5243               2               256             2.5, 10, 50, 100
  45  * AD5248               2               256             2.5, 10, 50, 100
  46  * AD5242               2               256             20, 50, 200
  47  * AD5280               1               256             20, 50, 200
  48  * AD5282               2               256             20, 50, 200
  49  * ADN2860              3               512             25, 250
  50  * AD5273               1               64              1, 10, 50, 100 (OTP)
  51  * AD5171               1               64              5, 10, 50, 100 (OTP)
  52  * AD5170               1               256             2.5, 10, 50, 100 (OTP)
  53  * AD5172               2               256             2.5, 10, 50, 100 (OTP)
  54  * AD5173               2               256             2.5, 10, 50, 100 (OTP)
  55  *
  56  * See Documentation/misc-devices/ad525x_dpot.txt for more info.
  57  *
  58  * derived from ad5258.c
  59  * Copyright (c) 2009 Cyber Switching, Inc.
  60  * Author: Chris Verges <chrisv@cyberswitching.com>
  61  *
  62  * derived from ad5252.c
  63  * Copyright (c) 2006 Michael Hennerich <hennerich@blackfin.uclinux.org>
  64  *
  65  * Licensed under the GPL-2 or later.
  66  */
  67
  68 #include <linux/module.h>
  69 #include <linux/device.h>
  70 #include <linux/kernel.h>
  71 #include <linux/init.h>
  72 #include <linux/delay.h>
  73 #include <linux/slab.h>
  74
  75 #define DRIVER_VERSION                  "0.2"
  76
  77 #include "ad525x_dpot.h"
  78
  79 /*
  80  * Client data (each client gets its own)
  81  */
  82
  83 struct dpot_data {
  84         struct ad_dpot_bus_data bdata;
  85         struct mutex update_lock;
  86         unsigned rdac_mask;
  87         unsigned max_pos;
  88         unsigned long devid;
  89         unsigned uid;
  90         unsigned feat;
  91         unsigned wipers;
  92         u16 rdac_cache[MAX_RDACS];
  93         DECLARE_BITMAP(otp_en_mask, MAX_RDACS);
  94 };
  95
  96 static inline int dpot_read_d8(struct dpot_data *dpot)
  97 {
  98         return dpot->bdata.bops->read_d8(dpot->bdata.client);
  99 }
 100
 101 static inline int dpot_read_r8d8(struct dpot_data *dpot, u8 reg)
 102 {
 103         return dpot->bdata.bops->read_r8d8(dpot->bdata.client, reg);
 104 }
 105
 106 static inline int dpot_read_r8d16(struct dpot_data *dpot, u8 reg)
 107 {
 108         return dpot->bdata.bops->read_r8d16(dpot->bdata.client, reg);
 109 }
 110
 111 static inline int dpot_write_d8(struct dpot_data *dpot, u8 val)
 112 {
 113         return dpot->bdata.bops->write_d8(dpot->bdata.client, val);
 114 }
 115
 116 static inline int dpot_write_r8d8(struct dpot_data *dpot, u8 reg, u16 val)
 117 {
 118         return dpot->bdata.bops->write_r8d8(dpot->bdata.client, reg, val);
 119 }
 120
 121 static inline int dpot_write_r8d16(struct dpot_data *dpot, u8 reg, u16 val)
 122 {
 123         return dpot->bdata.bops->write_r8d16(dpot->bdata.client, reg, val);
 124 }
 125
 126 static s32 dpot_read_spi(struct dpot_data *dpot, u8 reg)
 127 {
 128         unsigned ctrl = 0;
 129
 130         if (!(reg & (DPOT_ADDR_EEPROM | DPOT_ADDR_CMD))) {
 131
 132                 if (dpot->feat & F_RDACS_WONLY)
 133                         return dpot->rdac_cache[reg & DPOT_RDAC_MASK];
 134
 135                 if (dpot->uid == DPOT_UID(AD5291_ID) ||
 136                         dpot->uid == DPOT_UID(AD5292_ID) ||
 137                         dpot->uid == DPOT_UID(AD5293_ID))
 138                         return dpot_read_r8d8(dpot,
 139                                 DPOT_AD5291_READ_RDAC << 2);
 140
 141                 ctrl = DPOT_SPI_READ_RDAC;
 142         } else if (reg & DPOT_ADDR_EEPROM) {
 143                 ctrl = DPOT_SPI_READ_EEPROM;
 144         }
 145
 146         if (dpot->feat & F_SPI_16BIT)
 147                 return dpot_read_r8d8(dpot, ctrl);
 148         else if (dpot->feat & F_SPI_24BIT)
 149                 return dpot_read_r8d16(dpot, ctrl);
 150
 151         return -EFAULT;
 152 }
 153
 154 static s32 dpot_read_i2c(struct dpot_data *dpot, u8 reg)
 155 {
 156         unsigned ctrl = 0;
 157         switch (dpot->uid) {
 158         case DPOT_UID(AD5246_ID):
 159         case DPOT_UID(AD5247_ID):
 160                 return dpot_read_d8(dpot);
 161         case DPOT_UID(AD5245_ID):
 162         case DPOT_UID(AD5241_ID):
 163         case DPOT_UID(AD5242_ID):
 164         case DPOT_UID(AD5243_ID):
 165         case DPOT_UID(AD5248_ID):
 166         case DPOT_UID(AD5280_ID):
 167         case DPOT_UID(AD5282_ID):
 168                 ctrl = ((reg & DPOT_RDAC_MASK) == DPOT_RDAC0) ?
 169                         0 : DPOT_AD5291_RDAC_AB;
 170                 return dpot_read_r8d8(dpot, ctrl);
 171         case DPOT_UID(AD5170_ID):
 172         case DPOT_UID(AD5171_ID):
 173         case DPOT_UID(AD5273_ID):
 174                         return dpot_read_d8(dpot);
 175         case DPOT_UID(AD5172_ID):
 176         case DPOT_UID(AD5173_ID):
 177                 ctrl = ((reg & DPOT_RDAC_MASK) == DPOT_RDAC0) ?
 178                         0 : DPOT_AD5272_3_A0;
 179                 return dpot_read_r8d8(dpot, ctrl);
 180         default:
 181                 if ((reg & DPOT_REG_TOL) || (dpot->max_pos > 256))
 182                         return dpot_read_r8d16(dpot, (reg & 0xF8) |
 183                                         ((reg & 0x7) << 1));
 184                 else
 185                         return dpot_read_r8d8(dpot, reg);
 186         }
 187 }
 188
 189 static s32 dpot_read(struct dpot_data *dpot, u8 reg)
 190 {
 191         if (dpot->feat & F_SPI)
 192                 return dpot_read_spi(dpot, reg);
 193         else
 194                 return dpot_read_i2c(dpot, reg);
 195 }
 196
 197 static s32 dpot_write_spi(struct dpot_data *dpot, u8 reg, u16 value)
 198 {
 199         unsigned val = 0;
 200
 201         if (!(reg & (DPOT_ADDR_EEPROM | DPOT_ADDR_CMD))) {
 202                 if (dpot->feat & F_RDACS_WONLY)
 203                         dpot->rdac_cache[reg & DPOT_RDAC_MASK] = value;
 204
 205                 if (dpot->feat & F_AD_APPDATA) {
 206                         if (dpot->feat & F_SPI_8BIT) {
 207                                 val = ((reg & DPOT_RDAC_MASK) <<
 208                                         DPOT_MAX_POS(dpot->devid)) |
 209                                         value;
 210                                 return dpot_write_d8(dpot, val);
 211                         } else if (dpot->feat & F_SPI_16BIT) {
 212                                 val = ((reg & DPOT_RDAC_MASK) <<
 213                                         DPOT_MAX_POS(dpot->devid)) |
 214                                         value;
 215                                 return dpot_write_r8d8(dpot, val >> 8,
 216                                         val & 0xFF);
 217                         } else
 218                                 BUG();
 219                 } else {
 220                         if (dpot->uid == DPOT_UID(AD5291_ID) ||
 221                                 dpot->uid == DPOT_UID(AD5292_ID) ||
 222                                 dpot->uid == DPOT_UID(AD5293_ID))
 223                                 return dpot_write_r8d8(dpot,
 224                                         (DPOT_AD5291_RDAC << 2) |
 225                                         (value >> 8), value & 0xFF);
 226
 227                         val = DPOT_SPI_RDAC | (reg & DPOT_RDAC_MASK);
 228                 }
 229         } else if (reg & DPOT_ADDR_EEPROM) {
 230                 val = DPOT_SPI_EEPROM | (reg & DPOT_RDAC_MASK);
 231         } else if (reg & DPOT_ADDR_CMD) {
 232                 switch (reg) {
 233                 case DPOT_DEC_ALL_6DB:
 234                         val = DPOT_SPI_DEC_ALL_6DB;
 235                         break;
 236                 case DPOT_INC_ALL_6DB:
 237                         val = DPOT_SPI_INC_ALL_6DB;
 238                         break;
 239                 case DPOT_DEC_ALL:
 240                         val = DPOT_SPI_DEC_ALL;
 241                         break;
 242                 case DPOT_INC_ALL:
 243                         val = DPOT_SPI_INC_ALL;
 244                         break;
 245                 }
 246         } else
 247                 BUG();
 248
 249         if (dpot->feat & F_SPI_16BIT)
 250                 return dpot_write_r8d8(dpot, val, value);
 251         else if (dpot->feat & F_SPI_24BIT)
 252                 return dpot_write_r8d16(dpot, val, value);
 253
 254         return -EFAULT;
 255 }
 256
 257 static s32 dpot_write_i2c(struct dpot_data *dpot, u8 reg, u16 value)
 258 {
 259         /* Only write the instruction byte for certain commands */
 260         unsigned tmp = 0, ctrl = 0;
 261
 262         switch (dpot->uid) {
 263         case DPOT_UID(AD5246_ID):
 264         case DPOT_UID(AD5247_ID):
 265                 return dpot_write_d8(dpot, value);
 266                 break;
 267
 268         case DPOT_UID(AD5245_ID):
 269         case DPOT_UID(AD5241_ID):
 270         case DPOT_UID(AD5242_ID):
 271         case DPOT_UID(AD5243_ID):
 272         case DPOT_UID(AD5248_ID):
 273         case DPOT_UID(AD5280_ID):
 274         case DPOT_UID(AD5282_ID):
 275                 ctrl = ((reg & DPOT_RDAC_MASK) == DPOT_RDAC0) ?
 276                         0 : DPOT_AD5291_RDAC_AB;
 277                 return dpot_write_r8d8(dpot, ctrl, value);
 278                 break;
 279         case DPOT_UID(AD5171_ID):
 280         case DPOT_UID(AD5273_ID):
 281                 if (reg & DPOT_ADDR_OTP) {
 282                         tmp = dpot_read_d8(dpot);
 283                         if (tmp >> 6) /* Ready to Program? */
 284                                 return -EFAULT;
 285                         ctrl = DPOT_AD5273_FUSE;
 286                 }
 287                 return dpot_write_r8d8(dpot, ctrl, value);
 288                 break;
 289         case DPOT_UID(AD5172_ID):
 290         case DPOT_UID(AD5173_ID):
 291                 ctrl = ((reg & DPOT_RDAC_MASK) == DPOT_RDAC0) ?
 292                         0 : DPOT_AD5272_3_A0;
 293                 if (reg & DPOT_ADDR_OTP) {
 294                         tmp = dpot_read_r8d16(dpot, ctrl);
 295                         if (tmp >> 14) /* Ready to Program? */
 296                                 return -EFAULT;
 297                         ctrl |= DPOT_AD5270_2_3_FUSE;
 298                 }
 299                 return dpot_write_r8d8(dpot, ctrl, value);
 300                 break;
 301         case DPOT_UID(AD5170_ID):
 302                 if (reg & DPOT_ADDR_OTP) {
 303                         tmp = dpot_read_r8d16(dpot, tmp);
 304                         if (tmp >> 14) /* Ready to Program? */
 305                                 return -EFAULT;
 306                         ctrl = DPOT_AD5270_2_3_FUSE;
 307                 }
 308                 return dpot_write_r8d8(dpot, ctrl, value);
 309                 break;
 310         default:
 311                 if (reg & DPOT_ADDR_CMD)
 312                         return dpot_write_d8(dpot, reg);
 313
 314                 if (dpot->max_pos > 256)
 315                         return dpot_write_r8d16(dpot, (reg & 0xF8) |
 316                                                 ((reg & 0x7) << 1), value);
 317                 else
 318                         /* All other registers require instruction + data bytes */
 319                         return dpot_write_r8d8(dpot, reg, value);
 320         }
 321 }
 322
 323
 324 static s32 dpot_write(struct dpot_data *dpot, u8 reg, u16 value)
 325 {
 326         if (dpot->feat & F_SPI)
 327                 return dpot_write_spi(dpot, reg, value);
 328         else
 329                 return dpot_write_i2c(dpot, reg, value);
 330 }
 331
 332 /* sysfs functions */
 333
 334 static ssize_t sysfs_show_reg(struct device *dev,
 335                               struct device_attribute *attr,
 336                               char *buf, u32 reg)
 337 {
 338         struct dpot_data *data = dev_get_drvdata(dev);
 339         s32 value;
 340
 341         if (reg & DPOT_ADDR_OTP_EN)
 342                 return sprintf(buf, "%s\n",
 343                         test_bit(DPOT_RDAC_MASK & reg, data->otp_en_mask) ?
 344                         "enabled" : "disabled");
 345
 346
 347         mutex_lock(&data->update_lock);
 348         value = dpot_read(data, reg);
 349         mutex_unlock(&data->update_lock);
 350
 351         if (value < 0)
 352                 return -EINVAL;
 353         /*
 354          * Let someone else deal with converting this ...
 355          * the tolerance is a two-byte value where the MSB
 356          * is a sign + integer value, and the LSB is a
 357          * decimal value.  See page 18 of the AD5258
 358          * datasheet (Rev. A) for more details.
 359          */
 360
 361         if (reg & DPOT_REG_TOL)
 362                 return sprintf(buf, "0x%04x\n", value & 0xFFFF);
 363         else
 364                 return sprintf(buf, "%u\n", value & data->rdac_mask);
 365 }
 366
 367 static ssize_t sysfs_set_reg(struct device *dev,
 368                              struct device_attribute *attr,
 369                              const char *buf, size_t count, u32 reg)
 370 {
 371         struct dpot_data *data = dev_get_drvdata(dev);
 372         unsigned long value;
 373         int err;
 374
 375         if (reg & DPOT_ADDR_OTP_EN) {
 376                 if (!strncmp(buf, "enabled", sizeof("enabled")))
 377                         set_bit(DPOT_RDAC_MASK & reg, data->otp_en_mask);
 378                 else
 379                         clear_bit(DPOT_RDAC_MASK & reg, data->otp_en_mask);
 380
 381                 return count;
 382         }
 383
 384         if ((reg & DPOT_ADDR_OTP) &&
 385                 !test_bit(DPOT_RDAC_MASK & reg, data->otp_en_mask))
 386                 return -EPERM;
 387
 388         err = strict_strtoul(buf, 10, &value);
 389         if (err)
 390                 return err;
 391
 392         if (value > data->rdac_mask)
 393                 value = data->rdac_mask;
 394
 395         mutex_lock(&data->update_lock);
 396         dpot_write(data, reg, value);
 397         if (reg & DPOT_ADDR_EEPROM)
 398                 msleep(26);     /* Sleep while the EEPROM updates */
 399         else if (reg & DPOT_ADDR_OTP)
 400                 msleep(400);    /* Sleep while the OTP updates */
 401         mutex_unlock(&data->update_lock);
 402
 403         return count;
 404 }
 405
 406 static ssize_t sysfs_do_cmd(struct device *dev,
 407                             struct device_attribute *attr,
 408                             const char *buf, size_t count, u32 reg)
 409 {
 410         struct dpot_data *data = dev_get_drvdata(dev);
 411
 412         mutex_lock(&data->update_lock);
 413         dpot_write(data, reg, 0);
 414         mutex_unlock(&data->update_lock);
 415
 416         return count;
 417 }
 418
 419 /* ------------------------------------------------------------------------- */
 420
 421 #define DPOT_DEVICE_SHOW(_name, _reg) static ssize_t \
 422 show_##_name(struct device *dev, \
 423                           struct device_attribute *attr, char *buf) \
 424 { \
 425         return sysfs_show_reg(dev, attr, buf, _reg); \
 426 }
 427
 428 #define DPOT_DEVICE_SET(_name, _reg) static ssize_t \
 429 set_##_name(struct device *dev, \
 430                          struct device_attribute *attr, \
 431                          const char *buf, size_t count) \
 432 { \
 433         return sysfs_set_reg(dev, attr, buf, count, _reg); \
 434 }
 435
 436 #define DPOT_DEVICE_SHOW_SET(name, reg) \
 437 DPOT_DEVICE_SHOW(name, reg) \
 438 DPOT_DEVICE_SET(name, reg) \
 439 static DEVICE_ATTR(name, S_IWUSR | S_IRUGO, show_##name, set_##name);
 440
 441 #define DPOT_DEVICE_SHOW_ONLY(name, reg) \
 442 DPOT_DEVICE_SHOW(name, reg) \
 443 static DEVICE_ATTR(name, S_IWUSR | S_IRUGO, show_##name, NULL);
 444
 445 DPOT_DEVICE_SHOW_SET(rdac0, DPOT_ADDR_RDAC | DPOT_RDAC0);
 446 DPOT_DEVICE_SHOW_SET(eeprom0, DPOT_ADDR_EEPROM | DPOT_RDAC0);
 447 DPOT_DEVICE_SHOW_ONLY(tolerance0, DPOT_ADDR_EEPROM | DPOT_TOL_RDAC0);
 448 DPOT_DEVICE_SHOW_SET(otp0, DPOT_ADDR_OTP | DPOT_RDAC0);
 449 DPOT_DEVICE_SHOW_SET(otp0en, DPOT_ADDR_OTP_EN | DPOT_RDAC0);
 450
 451 DPOT_DEVICE_SHOW_SET(rdac1, DPOT_ADDR_RDAC | DPOT_RDAC1);
 452 DPOT_DEVICE_SHOW_SET(eeprom1, DPOT_ADDR_EEPROM | DPOT_RDAC1);
 453 DPOT_DEVICE_SHOW_ONLY(tolerance1, DPOT_ADDR_EEPROM | DPOT_TOL_RDAC1);
 454 DPOT_DEVICE_SHOW_SET(otp1, DPOT_ADDR_OTP | DPOT_RDAC1);
 455 DPOT_DEVICE_SHOW_SET(otp1en, DPOT_ADDR_OTP_EN | DPOT_RDAC1);
 456
 457 DPOT_DEVICE_SHOW_SET(rdac2, DPOT_ADDR_RDAC | DPOT_RDAC2);
 458 DPOT_DEVICE_SHOW_SET(eeprom2, DPOT_ADDR_EEPROM | DPOT_RDAC2);
 459 DPOT_DEVICE_SHOW_ONLY(tolerance2, DPOT_ADDR_EEPROM | DPOT_TOL_RDAC2);
 460 DPOT_DEVICE_SHOW_SET(otp2, DPOT_ADDR_OTP | DPOT_RDAC2);
 461 DPOT_DEVICE_SHOW_SET(otp2en, DPOT_ADDR_OTP_EN | DPOT_RDAC2);
 462
 463 DPOT_DEVICE_SHOW_SET(rdac3, DPOT_ADDR_RDAC | DPOT_RDAC3);
 464 DPOT_DEVICE_SHOW_SET(eeprom3, DPOT_ADDR_EEPROM | DPOT_RDAC3);
 465 DPOT_DEVICE_SHOW_ONLY(tolerance3, DPOT_ADDR_EEPROM | DPOT_TOL_RDAC3);
 466 DPOT_DEVICE_SHOW_SET(otp3, DPOT_ADDR_OTP | DPOT_RDAC3);
 467 DPOT_DEVICE_SHOW_SET(otp3en, DPOT_ADDR_OTP_EN | DPOT_RDAC3);
 468
 469 DPOT_DEVICE_SHOW_SET(rdac4, DPOT_ADDR_RDAC | DPOT_RDAC4);
 470 DPOT_DEVICE_SHOW_SET(eeprom4, DPOT_ADDR_EEPROM | DPOT_RDAC4);
 471 DPOT_DEVICE_SHOW_ONLY(tolerance4, DPOT_ADDR_EEPROM | DPOT_TOL_RDAC4);
 472 DPOT_DEVICE_SHOW_SET(otp4, DPOT_ADDR_OTP | DPOT_RDAC4);
 473 DPOT_DEVICE_SHOW_SET(otp4en, DPOT_ADDR_OTP_EN | DPOT_RDAC4);
 474
 475 DPOT_DEVICE_SHOW_SET(rdac5, DPOT_ADDR_RDAC | DPOT_RDAC5);
 476 DPOT_DEVICE_SHOW_SET(eeprom5, DPOT_ADDR_EEPROM | DPOT_RDAC5);
 477 DPOT_DEVICE_SHOW_ONLY(tolerance5, DPOT_ADDR_EEPROM | DPOT_TOL_RDAC5);
 478 DPOT_DEVICE_SHOW_SET(otp5, DPOT_ADDR_OTP | DPOT_RDAC5);
 479 DPOT_DEVICE_SHOW_SET(otp5en, DPOT_ADDR_OTP_EN | DPOT_RDAC5);
 480
 481 static const struct attribute *dpot_attrib_wipers[] = {
 482         &dev_attr_rdac0.attr,
 483         &dev_attr_rdac1.attr,
 484         &dev_attr_rdac2.attr,
 485         &dev_attr_rdac3.attr,
 486         &dev_attr_rdac4.attr,
 487         &dev_attr_rdac5.attr,
 488         NULL
 489 };
 490
 491 static const struct attribute *dpot_attrib_eeprom[] = {
 492         &dev_attr_eeprom0.attr,
 493         &dev_attr_eeprom1.attr,
 494         &dev_attr_eeprom2.attr,
 495         &dev_attr_eeprom3.attr,
 496         &dev_attr_eeprom4.attr,
 497         &dev_attr_eeprom5.attr,
 498         NULL
 499 };
 500
 501 static const struct attribute *dpot_attrib_otp[] = {
 502         &dev_attr_otp0.attr,
 503         &dev_attr_otp1.attr,
 504         &dev_attr_otp2.attr,
 505         &dev_attr_otp3.attr,
 506         &dev_attr_otp4.attr,
 507         &dev_attr_otp5.attr,
 508         NULL
 509 };
 510
 511 static const struct attribute *dpot_attrib_otp_en[] = {
 512         &dev_attr_otp0en.attr,
 513         &dev_attr_otp1en.attr,
 514         &dev_attr_otp2en.attr,
 515         &dev_attr_otp3en.attr,
 516         &dev_attr_otp4en.attr,
 517         &dev_attr_otp5en.attr,
 518         NULL
 519 };
 520
 521 static const struct attribute *dpot_attrib_tolerance[] = {
 522         &dev_attr_tolerance0.attr,
 523         &dev_attr_tolerance1.attr,
 524         &dev_attr_tolerance2.attr,
 525         &dev_attr_tolerance3.attr,
 526         &dev_attr_tolerance4.attr,
 527         &dev_attr_tolerance5.attr,
 528         NULL
 529 };
 530
 531 /* ------------------------------------------------------------------------- */
 532
 533 #define DPOT_DEVICE_DO_CMD(_name, _cmd) static ssize_t \
 534 set_##_name(struct device *dev, \
 535                          struct device_attribute *attr, \
 536                          const char *buf, size_t count) \
 537 { \
 538         return sysfs_do_cmd(dev, attr, buf, count, _cmd); \
 539 } \
 540 static DEVICE_ATTR(_name, S_IWUSR | S_IRUGO, NULL, set_##_name);
 541
 542 DPOT_DEVICE_DO_CMD(inc_all, DPOT_INC_ALL);
 543 DPOT_DEVICE_DO_CMD(dec_all, DPOT_DEC_ALL);
 544 DPOT_DEVICE_DO_CMD(inc_all_6db, DPOT_INC_ALL_6DB);
 545 DPOT_DEVICE_DO_CMD(dec_all_6db, DPOT_DEC_ALL_6DB);
 546
 547 static struct attribute *ad525x_attributes_commands[] = {
 548         &dev_attr_inc_all.attr,
 549         &dev_attr_dec_all.attr,
 550         &dev_attr_inc_all_6db.attr,
 551         &dev_attr_dec_all_6db.attr,
 552         NULL
 553 };
 554
 555 static const struct attribute_group ad525x_group_commands = {
 556         .attrs = ad525x_attributes_commands,
 557 };
 558
 559 __devinit int ad_dpot_add_files(struct device *dev,
 560                 unsigned features, unsigned rdac)
 561 {
 562         int err = sysfs_create_file(&dev->kobj,
 563                 dpot_attrib_wipers[rdac]);
 564         if (features & F_CMD_EEP)
 565                 err |= sysfs_create_file(&dev->kobj,
 566                         dpot_attrib_eeprom[rdac]);
 567         if (features & F_CMD_TOL)
 568                 err |= sysfs_create_file(&dev->kobj,
 569                         dpot_attrib_tolerance[rdac]);
 570         if (features & F_CMD_OTP) {
 571                 err |= sysfs_create_file(&dev->kobj,
 572                         dpot_attrib_otp_en[rdac]);
 573                 err |= sysfs_create_file(&dev->kobj,
 574                         dpot_attrib_otp[rdac]);
 575         }
 576
 577         if (err)
 578                 dev_err(dev, "failed to register sysfs hooks for RDAC%d\n",
 579                         rdac);
 580
 581         return err;
 582 }
 583
 584 inline void ad_dpot_remove_files(struct device *dev,
 585                 unsigned features, unsigned rdac)
 586 {
 587         sysfs_remove_file(&dev->kobj,
 588                 dpot_attrib_wipers[rdac]);
 589         if (features & F_CMD_EEP)
 590                 sysfs_remove_file(&dev->kobj,
 591                         dpot_attrib_eeprom[rdac]);
 592         if (features & F_CMD_TOL)
 593                 sysfs_remove_file(&dev->kobj,
 594                         dpot_attrib_tolerance[rdac]);
 595         if (features & F_CMD_OTP) {
 596                 sysfs_remove_file(&dev->kobj,
 597                         dpot_attrib_otp_en[rdac]);
 598                 sysfs_remove_file(&dev->kobj,
 599                         dpot_attrib_otp[rdac]);
 600         }
 601 }
 602
 603 __devinit int ad_dpot_probe(struct device *dev,
 604                 struct ad_dpot_bus_data *bdata, const struct ad_dpot_id *id)
 605 {
 606
 607         struct dpot_data *data;
 608         int i, err = 0;
 609
 610         data = kzalloc(sizeof(struct dpot_data), GFP_KERNEL);
 611         if (!data) {
 612                 err = -ENOMEM;
 613                 goto exit;
 614         }
 615
 616         dev_set_drvdata(dev, data);
 617         mutex_init(&data->update_lock);
 618
 619         data->bdata = *bdata;
 620         data->devid = id->devid;
 621
 622         data->max_pos = 1 << DPOT_MAX_POS(data->devid);
 623         data->rdac_mask = data->max_pos - 1;
 624         data->feat = DPOT_FEAT(data->devid);
 625         data->uid = DPOT_UID(data->devid);
 626         data->wipers = DPOT_WIPERS(data->devid);
 627
 628         for (i = DPOT_RDAC0; i < MAX_RDACS; i++)
 629                 if (data->wipers & (1 << i)) {
 630                         err = ad_dpot_add_files(dev, data->feat, i);
 631                         if (err)
 632                                 goto exit_remove_files;
 633                         /* power-up midscale */
 634                         if (data->feat & F_RDACS_WONLY)
 635                                 data->rdac_cache[i] = data->max_pos / 2;
 636                 }
 637
 638         if (data->feat & F_CMD_INC)
 639                 err = sysfs_create_group(&dev->kobj, &ad525x_group_commands);
 640
 641         if (err) {
 642                 dev_err(dev, "failed to register sysfs hooks\n");
 643                 goto exit_free;
 644         }
 645
 646         dev_info(dev, "%s %d-Position Digital Potentiometer registered\n",
 647                  id->name, data->max_pos);
 648
 649         return 0;
 650
 651 exit_remove_files:
 652         for (i = DPOT_RDAC0; i < MAX_RDACS; i++)
 653                 if (data->wipers & (1 << i))
 654                         ad_dpot_remove_files(dev, data->feat, i);
 655
 656 exit_free:
 657         kfree(data);
 658         dev_set_drvdata(dev, NULL);
 659 exit:
 660         dev_err(dev, "failed to create client for %s ID 0x%lX\n",
 661                         id->name, id->devid);
 662         return err;
 663 }
 664 EXPORT_SYMBOL(ad_dpot_probe);
 665
 666 __devexit int ad_dpot_remove(struct device *dev)
 667 {
 668         struct dpot_data *data = dev_get_drvdata(dev);
 669         int i;
 670
 671         for (i = DPOT_RDAC0; i < MAX_RDACS; i++)
 672                 if (data->wipers & (1 << i))
 673                         ad_dpot_remove_files(dev, data->feat, i);
 674
 675         kfree(data);
 676
 677         return 0;
 678 }
 679 EXPORT_SYMBOL(ad_dpot_remove);
 680
 681
 682 MODULE_AUTHOR("Chris Verges <chrisv@cyberswitching.com>, "
 683               "Michael Hennerich <hennerich@blackfin.uclinux.org>");
 684 MODULE_DESCRIPTION("Digital potentiometer driver");
 685 MODULE_LICENSE("GPL");
 686 MODULE_VERSION(DRIVER_VERSION);