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