Unreachable code

|struct dpot_data {
| struct ad_dpot_bus_data bdata;
| struct mutex update_lock;
| unsigned rdac_mask;
| unsigned max_pos;
| unsigned long devid;
| unsigned uid;
| unsigned feat;
| unsigned wipers;
| u16 rdac_cache[6];
| unsigned long otp_en_mask[(((6) + (8 * sizeof(long)) - 1) / (8 * sizeof(long)))];
|};
|
|static inline int dpot_read_d8(struct dpot_data *dpot)
|{
| return dpot->bdata.bops->read_d8(dpot->bdata.client);
|}
|
|static inline int dpot_read_r8d8(struct dpot_data *dpot, u8 reg)
|{
| return dpot->bdata.bops->read_r8d8(dpot->bdata.client, reg);
|}
|
|static inline int dpot_read_r8d16(struct dpot_data *dpot, u8 reg)
|{
| return dpot->bdata.bops->read_r8d16(dpot->bdata.client, reg);
|}
|
|static inline int dpot_write_d8(struct dpot_data *dpot, u8 val)
|{
| return dpot->bdata.bops->write_d8(dpot->bdata.client, val);
|}
|
|static inline int dpot_write_r8d8(struct dpot_data *dpot, u8 reg, u16 val)
|{
| return dpot->bdata.bops->write_r8d8(dpot->bdata.client, reg, val);
|}
|
|static inline int dpot_write_r8d16(struct dpot_data *dpot, u8 reg, u16 val)
|{
| return dpot->bdata.bops->write_r8d16(dpot->bdata.client, reg, val);
|}
|
|static s32 dpot_read_spi(struct dpot_data *dpot, u8 reg)
|{
| unsigned ctrl = 0;
| int value;
|
| if (!(reg & ((0x1 << 5) | (0x1 << 7)))) {
|
|  if (dpot->feat & (1 << 5))
|   return dpot->rdac_cache[reg & 0x1F];
|  if (dpot->uid == (AD5291_ID & 0x3F) ||
|   dpot->uid == (AD5292_ID & 0x3F) ||
|   dpot->uid == (AD5293_ID & 0x3F)) {
|
|   value = dpot_read_r8d8(dpot,
|    0x02 << 2);
|
|   if (dpot->uid == (AD5291_ID & 0x3F))
|    value = value >> 2;
|
|   return value;
|  } else if (dpot->uid == (AD5270_ID & 0x3F) ||
|   dpot->uid == (AD5271_ID & 0x3F)) {
|
|   value = dpot_read_r8d8(dpot,
|    0x02 << 2);
|
|   if (value < 0)
|    return value;
|
|   if (dpot->uid == (AD5271_ID & 0x3F))
|    value = value >> 2;
|
|   return value;
|  }
|
|  ctrl = 0xA0;
| } else if (reg & (0x1 << 5)) {
|  ctrl = 0x90;
| }
|
| if (dpot->feat & (1 << 8))
|  return dpot_read_r8d8(dpot, ctrl);
| else if (dpot->feat & (1 << 9))
|  return dpot_read_r8d16(dpot, ctrl);
|
| return -14;
|}
|
|static s32 dpot_read_i2c(struct dpot_data *dpot, u8 reg)
|{
| int value;
| unsigned ctrl = 0;
| switch (dpot->uid) {
| case (AD5246_ID & 0x3F):
| case (AD5247_ID & 0x3F):
|  return dpot_read_d8(dpot);
| case (AD5245_ID & 0x3F):
| case (AD5241_ID & 0x3F):
| case (AD5242_ID & 0x3F):
| case (AD5243_ID & 0x3F):
| case (AD5248_ID & 0x3F):
| case (AD5280_ID & 0x3F):
| case (AD5282_ID & 0x3F):
|  ctrl = ((reg & 0x1F) == 0) ?
|   0 : 0x80;
|  return dpot_read_r8d8(dpot, ctrl);
| case (AD5170_ID & 0x3F):
| case (AD5171_ID & 0x3F):
| case (AD5273_ID & 0x3F):
|   return dpot_read_d8(dpot);
| case (AD5172_ID & 0x3F):
| case (AD5173_ID & 0x3F):
|  ctrl = ((reg & 0x1F) == 0) ?
|   0 : 0x08;
|  return dpot_read_r8d8(dpot, ctrl);
| case (AD5272_ID & 0x3F):
| case (AD5274_ID & 0x3F):
|   dpot_write_r8d8(dpot,
|    (0x02 << 2), 0);
|
|   value = dpot_read_r8d16(dpot,
|    0x01 << 2);
|
|   if (value < 0)
|    return value;
|
|
|
|
|   value = (__builtin_constant_p((__u16)(value)) ? ((__u16)( (((__u16)(value) & (__u16)0x00ffU) << 8) | (((__u16)(value) & (__u16)0xff00U) >> 8))) : __fswab16(value));
|
|   if (dpot->uid == (AD5271_ID & 0x3F))
|    value = value >> 2;
|  return value;
| default:
|  if ((reg & 0x18) || (dpot->max_pos > 256))
|   return dpot_read_r8d16(dpot, (reg & 0xF8) |
|     ((reg & 0x7) << 1));
|  else
|   return dpot_read_r8d8(dpot, reg);
| }
|}
|
|static s32 dpot_read(struct dpot_data *dpot, u8 reg)
|{
| if (dpot->feat & ((1 << 7) | (1 << 8) | (1 << 9)))
|  return dpot_read_spi(dpot, reg);
| else
|  return dpot_read_i2c(dpot, reg);
|}
|
|static s32 dpot_write_spi(struct dpot_data *dpot, u8 reg, u16 value)
|{
| unsigned val = 0;
|
| if (!(reg & ((0x1 << 5) | (0x1 << 7) | (0x1 << 6)))) {
|  if (dpot->feat & (1 << 5))
|   dpot->rdac_cache[reg & 0x1F] = value;
|
|  if (dpot->feat & (1 << 6)) {
|   if (dpot->feat & (1 << 7)) {
|    val = ((reg & 0x1F) <<
|     ((dpot->devid >> 6) & 0xF)) |
|     value;
|    return dpot_write_d8(dpot, val);
|   } else if (dpot->feat & (1 << 8)) {
|    val = ((reg & 0x1F) <<
|     ((dpot->devid >> 6) & 0xF)) |
|     value;
|    return dpot_write_r8d8(dpot, val >> 8,
|     val & 0xFF);
|   } else
|    __st_BUG_st__();
|  } else {
|   if (dpot->uid == (AD5291_ID & 0x3F) ||
|    dpot->uid == (AD5292_ID & 0x3F) ||
|    dpot->uid == (AD5293_ID & 0x3F)) {
|
|    dpot_write_r8d8(dpot, 0x06 << 2,
|      0x03);
|
|    if (dpot->uid == (AD5291_ID & 0x3F))
|     value = value << 2;
|
|    return dpot_write_r8d8(dpot,
|     (0x01 << 2) |
|     (value >> 8), value & 0xFF);
|   } else if (dpot->uid == (AD5270_ID & 0x3F) ||
|    dpot->uid == (AD5271_ID & 0x3F)) {
|    dpot_write_r8d8(dpot,
|      0x07 << 2,
|      0x03);
|
|    if (dpot->uid == (AD5271_ID & 0x3F))
|     value = value << 2;
|
|    return dpot_write_r8d8(dpot,
|     (0x01 << 2) |
|     (value >> 8), value & 0xFF);
|   }
|   val = 0xB0 | (reg & 0x1F);
|  }
| } else if (reg & (0x1 << 5)) {
|  val = 0x30 | (reg & 0x1F);
| } else if (reg & (0x1 << 7)) {
|  switch (reg) {
|  case ((0x1 << 7) | (0x4 << 3)):
|   val = 0x50;
|   break;
|  case ((0x1 << 7) | (0x9 << 3)):
|   val = 0xD0;
|   break;
|  case ((0x1 << 7) | (0x6 << 3)):
|   val = 0x70;
|   break;
|  case ((0x1 << 7) | (0xB << 3)):
|   val = 0xF0;
|   break;
|  }
| } else if (reg & (0x1 << 6)) {
|  if (dpot->uid == (AD5291_ID & 0x3F) ||
|   dpot->uid == (AD5292_ID & 0x3F)) {
|   return dpot_write_r8d8(dpot,
|    0x03 << 2, 0);
|  } else if (dpot->uid == (AD5270_ID & 0x3F) ||
|   dpot->uid == (AD5271_ID & 0x3F)) {
|   return dpot_write_r8d8(dpot,
|    0x03 << 2, 0);
|  }
| } else
|  __st_BUG_st__();
|
| if (dpot->feat & (1 << 8))
|  return dpot_write_r8d8(dpot, val, value);
| else if (dpot->feat & (1 << 9))
|  return dpot_write_r8d16(dpot, val, value);
|
| return -14;
|}
|
|static s32 dpot_write_i2c(struct dpot_data *dpot, u8 reg, u16 value)
|{
|
| unsigned tmp = 0, ctrl = 0;
|
| switch (dpot->uid) {
| case (AD5246_ID & 0x3F):
| case (AD5247_ID & 0x3F):
|  return dpot_write_d8(dpot, value);
|  break;
     |This node is unreachable prev next
|
| case (AD5245_ID & 0x3F):
| case (AD5241_ID & 0x3F):
| case (AD5242_ID & 0x3F):
| case (AD5243_ID & 0x3F):
| case (AD5248_ID & 0x3F):
| case (AD5280_ID & 0x3F):
| case (AD5282_ID & 0x3F):
|  ctrl = ((reg & 0x1F) == 0) ?
|   0 : 0x80;
|  return dpot_write_r8d8(dpot, ctrl, value);
|  break;
| case (AD5171_ID & 0x3F):
| case (AD5273_ID & 0x3F):
|  if (reg & (0x1 << 6)) {
|   tmp = dpot_read_d8(dpot);
|   if (tmp >> 6)
|    return -14;
|   ctrl = 0x80;
|  }
|  return dpot_write_r8d8(dpot, ctrl, value);
|  break;
| case (AD5172_ID & 0x3F):
| case (AD5173_ID & 0x3F):
|  ctrl = ((reg & 0x1F) == 0) ?
|   0 : 0x08;
|  if (reg & (0x1 << 6)) {
|   tmp = dpot_read_r8d16(dpot, ctrl);
|   if (tmp >> 14)
|    return -14;
|   ctrl |= 0x20;
|  }
|  return dpot_write_r8d8(dpot, ctrl, value);
|  break;
| case (AD5170_ID & 0x3F):
|  if (reg & (0x1 << 6)) {
|   tmp = dpot_read_r8d16(dpot, tmp);
|   if (tmp >> 14)
|    return -14;
|   ctrl = 0x20;
|  }
|  return dpot_write_r8d8(dpot, ctrl, value);
|  break;
| case (AD5272_ID & 0x3F):
| case (AD5274_ID & 0x3F):
|  dpot_write_r8d8(dpot, 0x07 << 2,
|    0x03);
|
|  if (reg & (0x1 << 6))
|   return dpot_write_r8d8(dpot,
|     0x03 << 2, 0);
|
|  if (dpot->uid == (AD5274_ID & 0x3F))
|   value = value << 2;
|
|  return dpot_write_r8d8(dpot, (0x01 << 2) |
|           (value >> 8), value & 0xFF);
|  break;
| default:
|  if (reg & (0x1 << 7))
|   return dpot_write_d8(dpot, reg);
|
|  if (dpot->max_pos > 256)
|   return dpot_write_r8d16(dpot, (reg & 0xF8) |
|      ((reg & 0x7) << 1), value);
|  else
|
|   return dpot_write_r8d8(dpot, reg, value);
| }
|}
|
|static s32 dpot_write(struct dpot_data *dpot, u8 reg, u16 value)
|{
| if (dpot->feat & ((1 << 7) | (1 << 8) | (1 << 9)))
|  return dpot_write_spi(dpot, reg, value);
| else
|  return dpot_write_i2c(dpot, reg, value);
|}
|
|
|
|static ssize_t sysfs_show_reg(struct device *dev,
|         struct device_attribute *attr,
|         char *buf, u32 reg)
|{
| struct dpot_data *data = dev_get_drvdata(dev);
| s32 value;
|
| if (reg & (0x1 << 9))
|  return sprintf(buf, "%s\n",
|   (__builtin_constant_p((0x1F & reg)) ? constant_test_bit((0x1F & reg), (data->otp_en_mask)) : variable_test_bit((0x1F & reg), (data->otp_en_mask))) ?
|   "enabled" : "disabled");
|
|
| __st_mutex_lock_st__(&data->update_lock);
| value = dpot_read(data, reg);
| __st_mutex_unlock_st__(&data->update_lock);
|
| if (value < 0)
|  return -22;
| if (reg & 0x18)
|  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 dpot_data *data = dev_get_drvdata(dev);
| unsigned long value;
| int err;
|
| if (reg & (0x1 << 9)) {
|  if (!strncmp(buf, "enabled", sizeof("enabled")))
|   set_bit(0x1F & reg, data->otp_en_mask);
|  else
|   clear_bit(0x1F & reg, data->otp_en_mask);
|
|  return count;
| }
|
| if ((reg & (0x1 << 6)) &&
|  !(__builtin_constant_p((0x1F & reg)) ? constant_test_bit((0x1F & reg), (data->otp_en_mask)) : variable_test_bit((0x1F & reg), (data->otp_en_mask))))
|  return -1;
|
| err = strict_strtoul(buf, 10, &value);
| if (err)
|  return err;
|
| if (value > data->rdac_mask)
|  value = data->rdac_mask;
|
| __st_mutex_lock_st__(&data->update_lock);
| dpot_write(data, reg, value);
| if (reg & (0x1 << 5))
|  msleep(26);
| else if (reg & (0x1 << 6))
|  msleep(400);
| __st_mutex_unlock_st__(&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 dpot_data *data = dev_get_drvdata(dev);
|
| __st_mutex_lock_st__(&data->update_lock);
| dpot_write(data, reg, 0);
| __st_mutex_unlock_st__(&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, (0x0 << 5) | 0); } 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, (0x0 << 5) | 0); } static struct device_attribute dev_attr_rdac0 = { .attr = {.name = "rdac0", .mode = 00200 | (00400|00040|00004) }, .show = show_rdac0, .store = set_rdac0, };;
|static ssize_t show_eeprom0(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x1 << 5) | 0); } 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, (0x1 << 5) | 0); } static struct device_attribute dev_attr_eeprom0 = { .attr = {.name = "eeprom0", .mode = 00200 | (00400|00040|00004) }, .show = show_eeprom0, .store = set_eeprom0, };;
|static ssize_t show_tolerance0(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x1 << 5) | (0x18 | 0)); } static struct device_attribute dev_attr_tolerance0 = { .attr = {.name = "tolerance0", .mode = 00200 | (00400|00040|00004) }, .show = show_tolerance0, .store = ((void *)0), };;
|static ssize_t show_otp0(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x1 << 6) | 0); } static ssize_t set_otp0(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { return sysfs_set_reg(dev, attr, buf, count, (0x1 << 6) | 0); } static struct device_attribute dev_attr_otp0 = { .attr = {.name = "otp0", .mode = 00200 | (00400|00040|00004) }, .show = show_otp0, .store = set_otp0, };;
|static ssize_t show_otp0en(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x1 << 9) | 0); } static ssize_t set_otp0en(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { return sysfs_set_reg(dev, attr, buf, count, (0x1 << 9) | 0); } static struct device_attribute dev_attr_otp0en = { .attr = {.name = "otp0en", .mode = 00200 | (00400|00040|00004) }, .show = show_otp0en, .store = set_otp0en, };;
|
|static ssize_t show_rdac1(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x0 << 5) | 1); } 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, (0x0 << 5) | 1); } static struct device_attribute dev_attr_rdac1 = { .attr = {.name = "rdac1", .mode = 00200 | (00400|00040|00004) }, .show = show_rdac1, .store = set_rdac1, };;
|static ssize_t show_eeprom1(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x1 << 5) | 1); } 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, (0x1 << 5) | 1); } static struct device_attribute dev_attr_eeprom1 = { .attr = {.name = "eeprom1", .mode = 00200 | (00400|00040|00004) }, .show = show_eeprom1, .store = set_eeprom1, };;
|static ssize_t show_tolerance1(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x1 << 5) | (0x18 | 1)); } static struct device_attribute dev_attr_tolerance1 = { .attr = {.name = "tolerance1", .mode = 00200 | (00400|00040|00004) }, .show = show_tolerance1, .store = ((void *)0), };;
|static ssize_t show_otp1(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x1 << 6) | 1); } static ssize_t set_otp1(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { return sysfs_set_reg(dev, attr, buf, count, (0x1 << 6) | 1); } static struct device_attribute dev_attr_otp1 = { .attr = {.name = "otp1", .mode = 00200 | (00400|00040|00004) }, .show = show_otp1, .store = set_otp1, };;
|static ssize_t show_otp1en(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x1 << 9) | 1); } static ssize_t set_otp1en(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { return sysfs_set_reg(dev, attr, buf, count, (0x1 << 9) | 1); } static struct device_attribute dev_attr_otp1en = { .attr = {.name = "otp1en", .mode = 00200 | (00400|00040|00004) }, .show = show_otp1en, .store = set_otp1en, };;
|
|static ssize_t show_rdac2(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x0 << 5) | 2); } 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, (0x0 << 5) | 2); } static struct device_attribute dev_attr_rdac2 = { .attr = {.name = "rdac2", .mode = 00200 | (00400|00040|00004) }, .show = show_rdac2, .store = set_rdac2, };;
|static ssize_t show_eeprom2(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x1 << 5) | 2); } 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, (0x1 << 5) | 2); } static struct device_attribute dev_attr_eeprom2 = { .attr = {.name = "eeprom2", .mode = 00200 | (00400|00040|00004) }, .show = show_eeprom2, .store = set_eeprom2, };;
|static ssize_t show_tolerance2(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x1 << 5) | (0x18 | 2)); } static struct device_attribute dev_attr_tolerance2 = { .attr = {.name = "tolerance2", .mode = 00200 | (00400|00040|00004) }, .show = show_tolerance2, .store = ((void *)0), };;
|static ssize_t show_otp2(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x1 << 6) | 2); } static ssize_t set_otp2(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { return sysfs_set_reg(dev, attr, buf, count, (0x1 << 6) | 2); } static struct device_attribute dev_attr_otp2 = { .attr = {.name = "otp2", .mode = 00200 | (00400|00040|00004) }, .show = show_otp2, .store = set_otp2, };;
|static ssize_t show_otp2en(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x1 << 9) | 2); } static ssize_t set_otp2en(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { return sysfs_set_reg(dev, attr, buf, count, (0x1 << 9) | 2); } static struct device_attribute dev_attr_otp2en = { .attr = {.name = "otp2en", .mode = 00200 | (00400|00040|00004) }, .show = show_otp2en, .store = set_otp2en, };;
|
|static ssize_t show_rdac3(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x0 << 5) | 3); } 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, (0x0 << 5) | 3); } static struct device_attribute dev_attr_rdac3 = { .attr = {.name = "rdac3", .mode = 00200 | (00400|00040|00004) }, .show = show_rdac3, .store = set_rdac3, };;
|static ssize_t show_eeprom3(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x1 << 5) | 3); } 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, (0x1 << 5) | 3); } static struct device_attribute dev_attr_eeprom3 = { .attr = {.name = "eeprom3", .mode = 00200 | (00400|00040|00004) }, .show = show_eeprom3, .store = set_eeprom3, };;
|static ssize_t show_tolerance3(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x1 << 5) | (0x18 | 3)); } static struct device_attribute dev_attr_tolerance3 = { .attr = {.name = "tolerance3", .mode = 00200 | (00400|00040|00004) }, .show = show_tolerance3, .store = ((void *)0), };;
|static ssize_t show_otp3(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x1 << 6) | 3); } static ssize_t set_otp3(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { return sysfs_set_reg(dev, attr, buf, count, (0x1 << 6) | 3); } static struct device_attribute dev_attr_otp3 = { .attr = {.name = "otp3", .mode = 00200 | (00400|00040|00004) }, .show = show_otp3, .store = set_otp3, };;
|static ssize_t show_otp3en(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x1 << 9) | 3); } static ssize_t set_otp3en(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { return sysfs_set_reg(dev, attr, buf, count, (0x1 << 9) | 3); } static struct device_attribute dev_attr_otp3en = { .attr = {.name = "otp3en", .mode = 00200 | (00400|00040|00004) }, .show = show_otp3en, .store = set_otp3en, };;
|
|static ssize_t show_rdac4(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x0 << 5) | 4); } static ssize_t set_rdac4(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { return sysfs_set_reg(dev, attr, buf, count, (0x0 << 5) | 4); } static struct device_attribute dev_attr_rdac4 = { .attr = {.name = "rdac4", .mode = 00200 | (00400|00040|00004) }, .show = show_rdac4, .store = set_rdac4, };;
|static ssize_t show_eeprom4(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x1 << 5) | 4); } static ssize_t set_eeprom4(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { return sysfs_set_reg(dev, attr, buf, count, (0x1 << 5) | 4); } static struct device_attribute dev_attr_eeprom4 = { .attr = {.name = "eeprom4", .mode = 00200 | (00400|00040|00004) }, .show = show_eeprom4, .store = set_eeprom4, };;
|static ssize_t show_tolerance4(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x1 << 5) | (0x18 | 4)); } static struct device_attribute dev_attr_tolerance4 = { .attr = {.name = "tolerance4", .mode = 00200 | (00400|00040|00004) }, .show = show_tolerance4, .store = ((void *)0), };;
|static ssize_t show_otp4(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x1 << 6) | 4); } static ssize_t set_otp4(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { return sysfs_set_reg(dev, attr, buf, count, (0x1 << 6) | 4); } static struct device_attribute dev_attr_otp4 = { .attr = {.name = "otp4", .mode = 00200 | (00400|00040|00004) }, .show = show_otp4, .store = set_otp4, };;
|static ssize_t show_otp4en(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x1 << 9) | 4); } static ssize_t set_otp4en(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { return sysfs_set_reg(dev, attr, buf, count, (0x1 << 9) | 4); } static struct device_attribute dev_attr_otp4en = { .attr = {.name = "otp4en", .mode = 00200 | (00400|00040|00004) }, .show = show_otp4en, .store = set_otp4en, };;
|
|static ssize_t show_rdac5(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x0 << 5) | 5); } static ssize_t set_rdac5(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { return sysfs_set_reg(dev, attr, buf, count, (0x0 << 5) | 5); } static struct device_attribute dev_attr_rdac5 = { .attr = {.name = "rdac5", .mode = 00200 | (00400|00040|00004) }, .show = show_rdac5, .store = set_rdac5, };;
|static ssize_t show_eeprom5(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x1 << 5) | 5); } static ssize_t set_eeprom5(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { return sysfs_set_reg(dev, attr, buf, count, (0x1 << 5) | 5); } static struct device_attribute dev_attr_eeprom5 = { .attr = {.name = "eeprom5", .mode = 00200 | (00400|00040|00004) }, .show = show_eeprom5, .store = set_eeprom5, };;
|static ssize_t show_tolerance5(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x1 << 5) | (0x18 | 5)); } static struct device_attribute dev_attr_tolerance5 = { .attr = {.name = "tolerance5", .mode = 00200 | (00400|00040|00004) }, .show = show_tolerance5, .store = ((void *)0), };;
|static ssize_t show_otp5(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x1 << 6) | 5); } static ssize_t set_otp5(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { return sysfs_set_reg(dev, attr, buf, count, (0x1 << 6) | 5); } static struct device_attribute dev_attr_otp5 = { .attr = {.name = "otp5", .mode = 00200 | (00400|00040|00004) }, .show = show_otp5, .store = set_otp5, };;
|static ssize_t show_otp5en(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_show_reg(dev, attr, buf, (0x1 << 9) | 5); } static ssize_t set_otp5en(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { return sysfs_set_reg(dev, attr, buf, count, (0x1 << 9) | 5); } static struct device_attribute dev_attr_otp5en = { .attr = {.name = "otp5en", .mode = 00200 | (00400|00040|00004) }, .show = show_otp5en, .store = set_otp5en, };;
|
|static const struct attribute *dpot_attrib_wipers[] = {
| &dev_attr_rdac0.attr,
| &dev_attr_rdac1.attr,
| &dev_attr_rdac2.attr,
| &dev_attr_rdac3.attr,
| &dev_attr_rdac4.attr,
| &dev_attr_rdac5.attr,
| ((void *)0)
|};
|
|static const struct attribute *dpot_attrib_eeprom[] = {
| &dev_attr_eeprom0.attr,
| &dev_attr_eeprom1.attr,
| &dev_attr_eeprom2.attr,
| &dev_attr_eeprom3.attr,
| &dev_attr_eeprom4.attr,
| &dev_attr_eeprom5.attr,
| ((void *)0)
|};
|
|static const struct attribute *dpot_attrib_otp[] = {
| &dev_attr_otp0.attr,
| &dev_attr_otp1.attr,
| &dev_attr_otp2.attr,
| &dev_attr_otp3.attr,
| &dev_attr_otp4.attr,
| &dev_attr_otp5.attr,
| ((void *)0)
|};
|
|static const struct attribute *dpot_attrib_otp_en[] = {
| &dev_attr_otp0en.attr,
| &dev_attr_otp1en.attr,
| &dev_attr_otp2en.attr,
| &dev_attr_otp3en.attr,
| &dev_attr_otp4en.attr,
| &dev_attr_otp5en.attr,
| ((void *)0)
|};
|
|static const struct attribute *dpot_attrib_tolerance[] = {
| &dev_attr_tolerance0.attr,
| &dev_attr_tolerance1.attr,
| &dev_attr_tolerance2.attr,
| &dev_attr_tolerance3.attr,
| &dev_attr_tolerance4.attr,
| &dev_attr_tolerance5.attr,
| ((void *)0)
|};
|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, ((0x1 << 7) | (0xB << 3))); } static struct device_attribute dev_attr_inc_all = { .attr = {.name = "inc_all", .mode = 00200 | (00400|00040|00004) }, .show = ((void *)0), .store = 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, ((0x1 << 7) | (0x6 << 3))); } static struct device_attribute dev_attr_dec_all = { .attr = {.name = "dec_all", .mode = 00200 | (00400|00040|00004) }, .show = ((void *)0), .store = 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, ((0x1 << 7) | (0x9 << 3))); } static struct device_attribute dev_attr_inc_all_6db = { .attr = {.name = "inc_all_6db", .mode = 00200 | (00400|00040|00004) }, .show = ((void *)0), .store = 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, ((0x1 << 7) | (0x4 << 3))); } static struct device_attribute dev_attr_dec_all_6db = { .attr = {.name = "dec_all_6db", .mode = 00200 | (00400|00040|00004) }, .show = ((void *)0), .store = 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,
| ((void *)0)
|};
|
|static const struct attribute_group ad525x_group_commands = {
| .attrs = ad525x_attributes_commands,
|};
|
| int ad_dpot_add_files(struct device *dev,
|  unsigned features, unsigned rdac)
|{
| int err = sysfs_create_file(&dev->kobj,
|  dpot_attrib_wipers[rdac]);
| if (features & (1 << 1))
|  err |= sysfs_create_file(&dev->kobj,
|   dpot_attrib_eeprom[rdac]);
| if (features & (1 << 3))
|  err |= sysfs_create_file(&dev->kobj,
|   dpot_attrib_tolerance[rdac]);
| if (features & (1 << 2)) {
|  err |= sysfs_create_file(&dev->kobj,
|   dpot_attrib_otp_en[rdac]);
|  err |= sysfs_create_file(&dev->kobj,
|   dpot_attrib_otp[rdac]);
| }
|
| if (err)
|  dev_err(dev, "failed to register sysfs hooks for RDAC%d\n",
|   rdac);
|
| return err;
|}
|
|inline void ad_dpot_remove_files(struct device *dev,
|  unsigned features, unsigned rdac)
|{
| sysfs_remove_file(&dev->kobj,
|  dpot_attrib_wipers[rdac]);
| if (features & (1 << 1))
|  sysfs_remove_file(&dev->kobj,
|   dpot_attrib_eeprom[rdac]);
| if (features & (1 << 3))
|  sysfs_remove_file(&dev->kobj,
|   dpot_attrib_tolerance[rdac]);
| if (features & (1 << 2)) {
|  sysfs_remove_file(&dev->kobj,
|   dpot_attrib_otp_en[rdac]);
|  sysfs_remove_file(&dev->kobj,
|   dpot_attrib_otp[rdac]);
| }
|}
|
| int ad_dpot_probe(struct device *dev,
|  struct ad_dpot_bus_data *bdata, const struct ad_dpot_id *id)
|{
|
| struct dpot_data *data;
| int i, err = 0;
|
| data = kzalloc(sizeof(struct dpot_data), __st_GFP_KERNEL_st__);
| if (!data) {
|  err = -12;
|  goto exit;
| }
|
| dev_set_drvdata(dev, data);
| do { static struct lock_class_key __key; __mutex_init((&data->update_lock), "&data->update_lock", &__key); } while (0);
|
| data->bdata = *bdata;
| data->devid = id->devid;
|
| data->max_pos = 1 << ((data->devid >> 6) & 0xF);
| data->rdac_mask = data->max_pos - 1;
| data->feat = (data->devid >> 18);
| data->uid = (data->devid & 0x3F);
| data->wipers = ((data->devid >> 10) & 0xFF);
|
| for (i = 0; i < 6; i++)
|  if (data->wipers & (1 << i)) {
|   err = ad_dpot_add_files(dev, data->feat, i);
|   if (err)
|    goto exit_remove_files;
|
|   if (data->feat & (1 << 5))
|    data->rdac_cache[i] = data->max_pos / 2;
|  }
|
| if (data->feat & (1 << 0))
|  err = sysfs_create_group(&dev->kobj, &ad525x_group_commands);
|
| if (err) {
|  dev_err(dev, "failed to register sysfs hooks\n");
|  goto exit_free;
| }
|
| _dev_info(dev, "%s %d-Position Digital Potentiometer registered\n", id->name, data->max_pos)
|                           ;
|
| return 0;
|
|exit_remove_files:
| for (i = 0; i < 6; i++)
|  if (data->wipers & (1 << i))
|   ad_dpot_remove_files(dev, data->feat, i);
|
|exit_free:
| kfree(data);
| dev_set_drvdata(dev, ((void *)0));
|exit:
| dev_err(dev, "failed to create client for %s ID 0x%lX\n",
|   id->name, id->devid);
| return err;
|}
|extern typeof(ad_dpot_probe) ad_dpot_probe; extern void *__crc_ad_dpot_probe ; static const unsigned long __kcrctab_ad_dpot_probe = (unsigned long) &__crc_ad_dpot_probe; static const char __kstrtab_ad_dpot_probe[] = "" "ad_dpot_probe"; static const struct kernel_symbol __ksymtab_ad_dpot_probe = { (unsigned long)&ad_dpot_probe, __kstrtab_ad_dpot_probe };
|
| int ad_dpot_remove(struct device *dev)
|{
| struct dpot_data *data = dev_get_drvdata(dev);
| int i;
|
| for (i = 0; i < 6; i++)
|  if (data->wipers & (1 << i))
|   ad_dpot_remove_files(dev, data->feat, i);
|
| kfree(data);
|
| return 0;
|}
|extern typeof(ad_dpot_remove) ad_dpot_remove; extern void *__crc_ad_dpot_remove ; static const unsigned long __kcrctab_ad_dpot_remove = (unsigned long) &__crc_ad_dpot_remove; static const char __kstrtab_ad_dpot_remove[] = "" "ad_dpot_remove"; static const struct kernel_symbol __ksymtab_ad_dpot_remove = { (unsigned long)&ad_dpot_remove, __kstrtab_ad_dpot_remove };
|
|
|static const char
| __mod_author770
| [] = "author" "=" "Chris Verges , " "Michael Hennerich "
|                                                            ;
|static const char __mod_description771[] = "description" "=" "Digital potentiometer driver";
|static const char __mod_license772[] = "license" "=" "GPL";
|static const char __mod_version773[] = "version" "=" "0.2";