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