1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * iio/dac/max5821.c 4 * Copyright (C) 2014 Philippe Reynes 5 */ 6 7 #include <linux/kernel.h> 8 #include <linux/module.h> 9 #include <linux/i2c.h> 10 #include <linux/iio/iio.h> 11 #include <linux/regulator/consumer.h> 12 13 #define MAX5821_MAX_DAC_CHANNELS 2 14 15 /* command bytes */ 16 #define MAX5821_LOAD_DAC_A_IN_REG_B 0x00 17 #define MAX5821_LOAD_DAC_B_IN_REG_A 0x10 18 #define MAX5821_EXTENDED_COMMAND_MODE 0xf0 19 #define MAX5821_READ_DAC_A_COMMAND 0xf1 20 #define MAX5821_READ_DAC_B_COMMAND 0xf2 21 22 #define MAX5821_EXTENDED_POWER_UP 0x00 23 #define MAX5821_EXTENDED_POWER_DOWN_MODE0 0x01 24 #define MAX5821_EXTENDED_POWER_DOWN_MODE1 0x02 25 #define MAX5821_EXTENDED_POWER_DOWN_MODE2 0x03 26 #define MAX5821_EXTENDED_DAC_A 0x04 27 #define MAX5821_EXTENDED_DAC_B 0x08 28 29 struct max5821_data { 30 struct i2c_client *client; 31 unsigned short vref_mv; 32 bool powerdown[MAX5821_MAX_DAC_CHANNELS]; 33 u8 powerdown_mode[MAX5821_MAX_DAC_CHANNELS]; 34 struct mutex lock; 35 }; 36 37 static const char * const max5821_powerdown_modes[] = { 38 "three_state", 39 "1kohm_to_gnd", 40 "100kohm_to_gnd", 41 }; 42 43 enum { 44 MAX5821_THREE_STATE, 45 MAX5821_1KOHM_TO_GND, 46 MAX5821_100KOHM_TO_GND 47 }; 48 49 static int max5821_get_powerdown_mode(struct iio_dev *indio_dev, 50 const struct iio_chan_spec *chan) 51 { 52 struct max5821_data *st = iio_priv(indio_dev); 53 54 return st->powerdown_mode[chan->channel]; 55 } 56 57 static int max5821_set_powerdown_mode(struct iio_dev *indio_dev, 58 const struct iio_chan_spec *chan, 59 unsigned int mode) 60 { 61 struct max5821_data *st = iio_priv(indio_dev); 62 63 st->powerdown_mode[chan->channel] = mode; 64 65 return 0; 66 } 67 68 static const struct iio_enum max5821_powerdown_mode_enum = { 69 .items = max5821_powerdown_modes, 70 .num_items = ARRAY_SIZE(max5821_powerdown_modes), 71 .get = max5821_get_powerdown_mode, 72 .set = max5821_set_powerdown_mode, 73 }; 74 75 static ssize_t max5821_read_dac_powerdown(struct iio_dev *indio_dev, 76 uintptr_t private, 77 const struct iio_chan_spec *chan, 78 char *buf) 79 { 80 struct max5821_data *st = iio_priv(indio_dev); 81 82 return sysfs_emit(buf, "%d\n", st->powerdown[chan->channel]); 83 } 84 85 static int max5821_sync_powerdown_mode(struct max5821_data *data, 86 const struct iio_chan_spec *chan) 87 { 88 u8 outbuf[2]; 89 int ret; 90 91 outbuf[0] = MAX5821_EXTENDED_COMMAND_MODE; 92 93 if (chan->channel == 0) 94 outbuf[1] = MAX5821_EXTENDED_DAC_A; 95 else 96 outbuf[1] = MAX5821_EXTENDED_DAC_B; 97 98 if (data->powerdown[chan->channel]) 99 outbuf[1] |= data->powerdown_mode[chan->channel] + 1; 100 else 101 outbuf[1] |= MAX5821_EXTENDED_POWER_UP; 102 103 ret = i2c_master_send(data->client, outbuf, sizeof(outbuf)); 104 if (ret < 0) 105 return ret; 106 if (ret != sizeof(outbuf)) 107 return -EIO; 108 109 return 0; 110 } 111 112 static ssize_t max5821_write_dac_powerdown(struct iio_dev *indio_dev, 113 uintptr_t private, 114 const struct iio_chan_spec *chan, 115 const char *buf, size_t len) 116 { 117 struct max5821_data *data = iio_priv(indio_dev); 118 bool powerdown; 119 int ret; 120 121 ret = kstrtobool(buf, &powerdown); 122 if (ret) 123 return ret; 124 125 data->powerdown[chan->channel] = powerdown; 126 127 ret = max5821_sync_powerdown_mode(data, chan); 128 if (ret < 0) 129 return ret; 130 131 return len; 132 } 133 134 static const struct iio_chan_spec_ext_info max5821_ext_info[] = { 135 { 136 .name = "powerdown", 137 .read = max5821_read_dac_powerdown, 138 .write = max5821_write_dac_powerdown, 139 .shared = IIO_SEPARATE, 140 }, 141 IIO_ENUM("powerdown_mode", IIO_SEPARATE, &max5821_powerdown_mode_enum), 142 IIO_ENUM_AVAILABLE("powerdown_mode", IIO_SHARED_BY_TYPE, &max5821_powerdown_mode_enum), 143 { } 144 }; 145 146 #define MAX5821_CHANNEL(chan) { \ 147 .type = IIO_VOLTAGE, \ 148 .indexed = 1, \ 149 .output = 1, \ 150 .channel = (chan), \ 151 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 152 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SCALE), \ 153 .ext_info = max5821_ext_info, \ 154 } 155 156 static const struct iio_chan_spec max5821_channels[] = { 157 MAX5821_CHANNEL(0), 158 MAX5821_CHANNEL(1) 159 }; 160 161 static const u8 max5821_read_dac_command[] = { 162 MAX5821_READ_DAC_A_COMMAND, 163 MAX5821_READ_DAC_B_COMMAND 164 }; 165 166 static const u8 max5821_load_dac_command[] = { 167 MAX5821_LOAD_DAC_A_IN_REG_B, 168 MAX5821_LOAD_DAC_B_IN_REG_A 169 }; 170 171 static int max5821_get_value(struct iio_dev *indio_dev, 172 int *val, int channel) 173 { 174 struct max5821_data *data = iio_priv(indio_dev); 175 struct i2c_client *client = data->client; 176 u8 outbuf[1]; 177 u8 inbuf[2]; 178 int ret; 179 180 if ((channel != 0) && (channel != 1)) 181 return -EINVAL; 182 183 outbuf[0] = max5821_read_dac_command[channel]; 184 185 mutex_lock(&data->lock); 186 187 ret = i2c_master_send(client, outbuf, 1); 188 if (ret < 0) { 189 mutex_unlock(&data->lock); 190 return ret; 191 } else if (ret != 1) { 192 mutex_unlock(&data->lock); 193 return -EIO; 194 } 195 196 ret = i2c_master_recv(client, inbuf, 2); 197 if (ret < 0) { 198 mutex_unlock(&data->lock); 199 return ret; 200 } else if (ret != 2) { 201 mutex_unlock(&data->lock); 202 return -EIO; 203 } 204 205 mutex_unlock(&data->lock); 206 207 *val = ((inbuf[0] & 0x0f) << 6) | (inbuf[1] >> 2); 208 209 return IIO_VAL_INT; 210 } 211 212 static int max5821_set_value(struct iio_dev *indio_dev, 213 int val, int channel) 214 { 215 struct max5821_data *data = iio_priv(indio_dev); 216 struct i2c_client *client = data->client; 217 u8 outbuf[2]; 218 int ret; 219 220 if ((val < 0) || (val > 1023)) 221 return -EINVAL; 222 223 if ((channel != 0) && (channel != 1)) 224 return -EINVAL; 225 226 outbuf[0] = max5821_load_dac_command[channel]; 227 outbuf[0] |= val >> 6; 228 outbuf[1] = (val & 0x3f) << 2; 229 230 ret = i2c_master_send(client, outbuf, 2); 231 if (ret < 0) 232 return ret; 233 else if (ret != 2) 234 return -EIO; 235 else 236 return 0; 237 } 238 239 static int max5821_read_raw(struct iio_dev *indio_dev, 240 struct iio_chan_spec const *chan, 241 int *val, int *val2, long mask) 242 { 243 struct max5821_data *data = iio_priv(indio_dev); 244 245 switch (mask) { 246 case IIO_CHAN_INFO_RAW: 247 return max5821_get_value(indio_dev, val, chan->channel); 248 case IIO_CHAN_INFO_SCALE: 249 *val = data->vref_mv; 250 *val2 = 10; 251 return IIO_VAL_FRACTIONAL_LOG2; 252 default: 253 return -EINVAL; 254 } 255 } 256 257 static int max5821_write_raw(struct iio_dev *indio_dev, 258 struct iio_chan_spec const *chan, 259 int val, int val2, long mask) 260 { 261 if (val2 != 0) 262 return -EINVAL; 263 264 switch (mask) { 265 case IIO_CHAN_INFO_RAW: 266 return max5821_set_value(indio_dev, val, chan->channel); 267 default: 268 return -EINVAL; 269 } 270 } 271 272 static int max5821_suspend(struct device *dev) 273 { 274 u8 outbuf[2] = { MAX5821_EXTENDED_COMMAND_MODE, 275 MAX5821_EXTENDED_DAC_A | 276 MAX5821_EXTENDED_DAC_B | 277 MAX5821_EXTENDED_POWER_DOWN_MODE2 }; 278 279 return i2c_master_send(to_i2c_client(dev), outbuf, 2); 280 } 281 282 static int max5821_resume(struct device *dev) 283 { 284 u8 outbuf[2] = { MAX5821_EXTENDED_COMMAND_MODE, 285 MAX5821_EXTENDED_DAC_A | 286 MAX5821_EXTENDED_DAC_B | 287 MAX5821_EXTENDED_POWER_UP }; 288 289 return i2c_master_send(to_i2c_client(dev), outbuf, 2); 290 } 291 292 static DEFINE_SIMPLE_DEV_PM_OPS(max5821_pm_ops, max5821_suspend, 293 max5821_resume); 294 295 static const struct iio_info max5821_info = { 296 .read_raw = max5821_read_raw, 297 .write_raw = max5821_write_raw, 298 }; 299 300 static int max5821_probe(struct i2c_client *client) 301 { 302 const struct i2c_device_id *id = i2c_client_get_device_id(client); 303 struct max5821_data *data; 304 struct iio_dev *indio_dev; 305 u32 tmp; 306 int ret; 307 308 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 309 if (!indio_dev) 310 return -ENOMEM; 311 data = iio_priv(indio_dev); 312 data->client = client; 313 mutex_init(&data->lock); 314 315 /* max5821 start in powerdown mode 100Kohm to ground */ 316 for (tmp = 0; tmp < MAX5821_MAX_DAC_CHANNELS; tmp++) { 317 data->powerdown[tmp] = true; 318 data->powerdown_mode[tmp] = MAX5821_100KOHM_TO_GND; 319 } 320 321 ret = devm_regulator_get_enable_read_voltage(&client->dev, "vref"); 322 if (ret) 323 return dev_err_probe(&client->dev, ret, 324 "Failed to get vref regulator voltage\n"); 325 326 data->vref_mv = ret / 1000; 327 328 indio_dev->name = id->name; 329 indio_dev->num_channels = ARRAY_SIZE(max5821_channels); 330 indio_dev->channels = max5821_channels; 331 indio_dev->modes = INDIO_DIRECT_MODE; 332 indio_dev->info = &max5821_info; 333 334 return devm_iio_device_register(&client->dev, indio_dev); 335 } 336 337 static const struct i2c_device_id max5821_id[] = { 338 { .name = "max5821" }, 339 { } 340 }; 341 MODULE_DEVICE_TABLE(i2c, max5821_id); 342 343 static const struct of_device_id max5821_of_match[] = { 344 { .compatible = "maxim,max5821" }, 345 { } 346 }; 347 MODULE_DEVICE_TABLE(of, max5821_of_match); 348 349 static struct i2c_driver max5821_driver = { 350 .driver = { 351 .name = "max5821", 352 .of_match_table = max5821_of_match, 353 .pm = pm_sleep_ptr(&max5821_pm_ops), 354 }, 355 .probe = max5821_probe, 356 .id_table = max5821_id, 357 }; 358 module_i2c_driver(max5821_driver); 359 360 MODULE_AUTHOR("Philippe Reynes <tremyfr@yahoo.fr>"); 361 MODULE_DESCRIPTION("MAX5821 DAC"); 362 MODULE_LICENSE("GPL v2"); 363