1 /* 2 * mcp4725.c - Support for Microchip MCP4725/6 3 * 4 * Copyright (C) 2012 Peter Meerwald <pmeerw@pmeerw.net> 5 * 6 * Based on max517 by Roland Stigge <stigge@antcom.de> 7 * 8 * This file is subject to the terms and conditions of version 2 of 9 * the GNU General Public License. See the file COPYING in the main 10 * directory of this archive for more details. 11 * 12 * driver for the Microchip I2C 12-bit digital-to-analog converter (DAC) 13 * (7-bit I2C slave address 0x60, the three LSBs can be configured in 14 * hardware) 15 */ 16 17 #include <linux/module.h> 18 #include <linux/i2c.h> 19 #include <linux/err.h> 20 #include <linux/delay.h> 21 #include <linux/regulator/consumer.h> 22 23 #include <linux/iio/iio.h> 24 #include <linux/iio/sysfs.h> 25 26 #include <linux/iio/dac/mcp4725.h> 27 28 #define MCP4725_DRV_NAME "mcp4725" 29 30 #define MCP472X_REF_VDD 0x00 31 #define MCP472X_REF_VREF_UNBUFFERED 0x02 32 #define MCP472X_REF_VREF_BUFFERED 0x03 33 34 struct mcp4725_data { 35 struct i2c_client *client; 36 int id; 37 unsigned ref_mode; 38 bool vref_buffered; 39 u16 dac_value; 40 bool powerdown; 41 unsigned powerdown_mode; 42 struct regulator *vdd_reg; 43 struct regulator *vref_reg; 44 }; 45 46 static int mcp4725_suspend(struct device *dev) 47 { 48 struct mcp4725_data *data = iio_priv(i2c_get_clientdata( 49 to_i2c_client(dev))); 50 u8 outbuf[2]; 51 52 outbuf[0] = (data->powerdown_mode + 1) << 4; 53 outbuf[1] = 0; 54 data->powerdown = true; 55 56 return i2c_master_send(data->client, outbuf, 2); 57 } 58 59 static int mcp4725_resume(struct device *dev) 60 { 61 struct mcp4725_data *data = iio_priv(i2c_get_clientdata( 62 to_i2c_client(dev))); 63 u8 outbuf[2]; 64 65 /* restore previous DAC value */ 66 outbuf[0] = (data->dac_value >> 8) & 0xf; 67 outbuf[1] = data->dac_value & 0xff; 68 data->powerdown = false; 69 70 return i2c_master_send(data->client, outbuf, 2); 71 } 72 73 #ifdef CONFIG_PM_SLEEP 74 static SIMPLE_DEV_PM_OPS(mcp4725_pm_ops, mcp4725_suspend, mcp4725_resume); 75 #define MCP4725_PM_OPS (&mcp4725_pm_ops) 76 #else 77 #define MCP4725_PM_OPS NULL 78 #endif 79 80 static ssize_t mcp4725_store_eeprom(struct device *dev, 81 struct device_attribute *attr, const char *buf, size_t len) 82 { 83 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 84 struct mcp4725_data *data = iio_priv(indio_dev); 85 int tries = 20; 86 u8 inoutbuf[3]; 87 bool state; 88 int ret; 89 90 ret = strtobool(buf, &state); 91 if (ret < 0) 92 return ret; 93 94 if (!state) 95 return 0; 96 97 inoutbuf[0] = 0x60; /* write EEPROM */ 98 inoutbuf[0] |= data->ref_mode << 3; 99 inoutbuf[1] = data->dac_value >> 4; 100 inoutbuf[2] = (data->dac_value & 0xf) << 4; 101 102 ret = i2c_master_send(data->client, inoutbuf, 3); 103 if (ret < 0) 104 return ret; 105 else if (ret != 3) 106 return -EIO; 107 108 /* wait for write complete, takes up to 50ms */ 109 while (tries--) { 110 msleep(20); 111 ret = i2c_master_recv(data->client, inoutbuf, 3); 112 if (ret < 0) 113 return ret; 114 else if (ret != 3) 115 return -EIO; 116 117 if (inoutbuf[0] & 0x80) 118 break; 119 } 120 121 if (tries < 0) { 122 dev_err(&data->client->dev, 123 "mcp4725_store_eeprom() failed, incomplete\n"); 124 return -EIO; 125 } 126 127 return len; 128 } 129 130 static IIO_DEVICE_ATTR(store_eeprom, S_IWUSR, NULL, mcp4725_store_eeprom, 0); 131 132 static struct attribute *mcp4725_attributes[] = { 133 &iio_dev_attr_store_eeprom.dev_attr.attr, 134 NULL, 135 }; 136 137 static const struct attribute_group mcp4725_attribute_group = { 138 .attrs = mcp4725_attributes, 139 }; 140 141 static const char * const mcp4725_powerdown_modes[] = { 142 "1kohm_to_gnd", 143 "100kohm_to_gnd", 144 "500kohm_to_gnd" 145 }; 146 147 static const char * const mcp4726_powerdown_modes[] = { 148 "1kohm_to_gnd", 149 "125kohm_to_gnd", 150 "640kohm_to_gnd" 151 }; 152 153 static int mcp4725_get_powerdown_mode(struct iio_dev *indio_dev, 154 const struct iio_chan_spec *chan) 155 { 156 struct mcp4725_data *data = iio_priv(indio_dev); 157 158 return data->powerdown_mode; 159 } 160 161 static int mcp4725_set_powerdown_mode(struct iio_dev *indio_dev, 162 const struct iio_chan_spec *chan, unsigned mode) 163 { 164 struct mcp4725_data *data = iio_priv(indio_dev); 165 166 data->powerdown_mode = mode; 167 168 return 0; 169 } 170 171 static ssize_t mcp4725_read_powerdown(struct iio_dev *indio_dev, 172 uintptr_t private, const struct iio_chan_spec *chan, char *buf) 173 { 174 struct mcp4725_data *data = iio_priv(indio_dev); 175 176 return sprintf(buf, "%d\n", data->powerdown); 177 } 178 179 static ssize_t mcp4725_write_powerdown(struct iio_dev *indio_dev, 180 uintptr_t private, const struct iio_chan_spec *chan, 181 const char *buf, size_t len) 182 { 183 struct mcp4725_data *data = iio_priv(indio_dev); 184 bool state; 185 int ret; 186 187 ret = strtobool(buf, &state); 188 if (ret) 189 return ret; 190 191 if (state) 192 ret = mcp4725_suspend(&data->client->dev); 193 else 194 ret = mcp4725_resume(&data->client->dev); 195 if (ret < 0) 196 return ret; 197 198 return len; 199 } 200 201 enum { 202 MCP4725, 203 MCP4726, 204 }; 205 206 static const struct iio_enum mcp472x_powerdown_mode_enum[] = { 207 [MCP4725] = { 208 .items = mcp4725_powerdown_modes, 209 .num_items = ARRAY_SIZE(mcp4725_powerdown_modes), 210 .get = mcp4725_get_powerdown_mode, 211 .set = mcp4725_set_powerdown_mode, 212 }, 213 [MCP4726] = { 214 .items = mcp4726_powerdown_modes, 215 .num_items = ARRAY_SIZE(mcp4726_powerdown_modes), 216 .get = mcp4725_get_powerdown_mode, 217 .set = mcp4725_set_powerdown_mode, 218 }, 219 }; 220 221 static const struct iio_chan_spec_ext_info mcp4725_ext_info[] = { 222 { 223 .name = "powerdown", 224 .read = mcp4725_read_powerdown, 225 .write = mcp4725_write_powerdown, 226 .shared = IIO_SEPARATE, 227 }, 228 IIO_ENUM("powerdown_mode", IIO_SEPARATE, 229 &mcp472x_powerdown_mode_enum[MCP4725]), 230 IIO_ENUM_AVAILABLE("powerdown_mode", 231 &mcp472x_powerdown_mode_enum[MCP4725]), 232 { }, 233 }; 234 235 static const struct iio_chan_spec_ext_info mcp4726_ext_info[] = { 236 { 237 .name = "powerdown", 238 .read = mcp4725_read_powerdown, 239 .write = mcp4725_write_powerdown, 240 .shared = IIO_SEPARATE, 241 }, 242 IIO_ENUM("powerdown_mode", IIO_SEPARATE, 243 &mcp472x_powerdown_mode_enum[MCP4726]), 244 IIO_ENUM_AVAILABLE("powerdown_mode", 245 &mcp472x_powerdown_mode_enum[MCP4726]), 246 { }, 247 }; 248 249 static const struct iio_chan_spec mcp472x_channel[] = { 250 [MCP4725] = { 251 .type = IIO_VOLTAGE, 252 .indexed = 1, 253 .output = 1, 254 .channel = 0, 255 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), 256 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), 257 .ext_info = mcp4725_ext_info, 258 }, 259 [MCP4726] = { 260 .type = IIO_VOLTAGE, 261 .indexed = 1, 262 .output = 1, 263 .channel = 0, 264 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), 265 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), 266 .ext_info = mcp4726_ext_info, 267 }, 268 }; 269 270 static int mcp4725_set_value(struct iio_dev *indio_dev, int val) 271 { 272 struct mcp4725_data *data = iio_priv(indio_dev); 273 u8 outbuf[2]; 274 int ret; 275 276 if (val >= (1 << 12) || val < 0) 277 return -EINVAL; 278 279 outbuf[0] = (val >> 8) & 0xf; 280 outbuf[1] = val & 0xff; 281 282 ret = i2c_master_send(data->client, outbuf, 2); 283 if (ret < 0) 284 return ret; 285 else if (ret != 2) 286 return -EIO; 287 else 288 return 0; 289 } 290 291 static int mcp4726_set_cfg(struct iio_dev *indio_dev) 292 { 293 struct mcp4725_data *data = iio_priv(indio_dev); 294 u8 outbuf[3]; 295 int ret; 296 297 outbuf[0] = 0x40; 298 outbuf[0] |= data->ref_mode << 3; 299 if (data->powerdown) 300 outbuf[0] |= data->powerdown << 1; 301 outbuf[1] = data->dac_value >> 4; 302 outbuf[2] = (data->dac_value & 0xf) << 4; 303 304 ret = i2c_master_send(data->client, outbuf, 3); 305 if (ret < 0) 306 return ret; 307 else if (ret != 3) 308 return -EIO; 309 else 310 return 0; 311 } 312 313 static int mcp4725_read_raw(struct iio_dev *indio_dev, 314 struct iio_chan_spec const *chan, 315 int *val, int *val2, long mask) 316 { 317 struct mcp4725_data *data = iio_priv(indio_dev); 318 int ret; 319 320 switch (mask) { 321 case IIO_CHAN_INFO_RAW: 322 *val = data->dac_value; 323 return IIO_VAL_INT; 324 case IIO_CHAN_INFO_SCALE: 325 if (data->ref_mode == MCP472X_REF_VDD) 326 ret = regulator_get_voltage(data->vdd_reg); 327 else 328 ret = regulator_get_voltage(data->vref_reg); 329 330 if (ret < 0) 331 return ret; 332 333 *val = ret / 1000; 334 *val2 = 12; 335 return IIO_VAL_FRACTIONAL_LOG2; 336 } 337 return -EINVAL; 338 } 339 340 static int mcp4725_write_raw(struct iio_dev *indio_dev, 341 struct iio_chan_spec const *chan, 342 int val, int val2, long mask) 343 { 344 struct mcp4725_data *data = iio_priv(indio_dev); 345 int ret; 346 347 switch (mask) { 348 case IIO_CHAN_INFO_RAW: 349 ret = mcp4725_set_value(indio_dev, val); 350 data->dac_value = val; 351 break; 352 default: 353 ret = -EINVAL; 354 break; 355 } 356 357 return ret; 358 } 359 360 static const struct iio_info mcp4725_info = { 361 .read_raw = mcp4725_read_raw, 362 .write_raw = mcp4725_write_raw, 363 .attrs = &mcp4725_attribute_group, 364 .driver_module = THIS_MODULE, 365 }; 366 367 static int mcp4725_probe(struct i2c_client *client, 368 const struct i2c_device_id *id) 369 { 370 struct mcp4725_data *data; 371 struct iio_dev *indio_dev; 372 struct mcp4725_platform_data *pdata = dev_get_platdata(&client->dev); 373 u8 inbuf[4]; 374 u8 pd; 375 u8 ref; 376 int err; 377 378 if (!pdata) { 379 dev_err(&client->dev, "invalid platform data"); 380 return -EINVAL; 381 } 382 383 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 384 if (indio_dev == NULL) 385 return -ENOMEM; 386 data = iio_priv(indio_dev); 387 i2c_set_clientdata(client, indio_dev); 388 data->client = client; 389 data->id = id->driver_data; 390 391 if (data->id == MCP4725 && pdata->use_vref) { 392 dev_err(&client->dev, 393 "external reference is unavailable on MCP4725"); 394 return -EINVAL; 395 } 396 397 if (!pdata->use_vref && pdata->vref_buffered) { 398 dev_err(&client->dev, 399 "buffering is unavailable on the internal reference"); 400 return -EINVAL; 401 } 402 403 if (!pdata->use_vref) 404 data->ref_mode = MCP472X_REF_VDD; 405 else 406 data->ref_mode = pdata->vref_buffered ? 407 MCP472X_REF_VREF_BUFFERED : 408 MCP472X_REF_VREF_UNBUFFERED; 409 410 data->vdd_reg = devm_regulator_get(&client->dev, "vdd"); 411 if (IS_ERR(data->vdd_reg)) 412 return PTR_ERR(data->vdd_reg); 413 414 err = regulator_enable(data->vdd_reg); 415 if (err) 416 return err; 417 418 if (pdata->use_vref) { 419 data->vref_reg = devm_regulator_get(&client->dev, "vref"); 420 if (IS_ERR(data->vref_reg)) { 421 err = PTR_ERR(data->vdd_reg); 422 goto err_disable_vdd_reg; 423 } 424 425 err = regulator_enable(data->vref_reg); 426 if (err) 427 goto err_disable_vdd_reg; 428 } 429 430 indio_dev->dev.parent = &client->dev; 431 indio_dev->name = id->name; 432 indio_dev->info = &mcp4725_info; 433 indio_dev->channels = &mcp472x_channel[id->driver_data]; 434 indio_dev->num_channels = 1; 435 indio_dev->modes = INDIO_DIRECT_MODE; 436 437 /* read current DAC value and settings */ 438 err = i2c_master_recv(client, inbuf, data->id == MCP4725 ? 3 : 4); 439 440 if (err < 0) { 441 dev_err(&client->dev, "failed to read DAC value"); 442 goto err_disable_vref_reg; 443 } 444 pd = (inbuf[0] >> 1) & 0x3; 445 data->powerdown = pd > 0 ? true : false; 446 data->powerdown_mode = pd ? pd - 1 : 2; /* largest resistor to gnd */ 447 data->dac_value = (inbuf[1] << 4) | (inbuf[2] >> 4); 448 if (data->id == MCP4726) 449 ref = (inbuf[3] >> 3) & 0x3; 450 451 if (data->id == MCP4726 && ref != data->ref_mode) { 452 dev_info(&client->dev, 453 "voltage reference mode differs (conf: %u, eeprom: %u), setting %u", 454 data->ref_mode, ref, data->ref_mode); 455 err = mcp4726_set_cfg(indio_dev); 456 if (err < 0) 457 goto err_disable_vref_reg; 458 } 459 460 err = iio_device_register(indio_dev); 461 if (err) 462 goto err_disable_vref_reg; 463 464 return 0; 465 466 err_disable_vref_reg: 467 if (data->vref_reg) 468 regulator_disable(data->vref_reg); 469 470 err_disable_vdd_reg: 471 regulator_disable(data->vdd_reg); 472 473 return err; 474 } 475 476 static int mcp4725_remove(struct i2c_client *client) 477 { 478 struct iio_dev *indio_dev = i2c_get_clientdata(client); 479 struct mcp4725_data *data = iio_priv(indio_dev); 480 481 iio_device_unregister(indio_dev); 482 483 if (data->vref_reg) 484 regulator_disable(data->vref_reg); 485 regulator_disable(data->vdd_reg); 486 487 return 0; 488 } 489 490 static const struct i2c_device_id mcp4725_id[] = { 491 { "mcp4725", MCP4725 }, 492 { "mcp4726", MCP4726 }, 493 { } 494 }; 495 MODULE_DEVICE_TABLE(i2c, mcp4725_id); 496 497 static struct i2c_driver mcp4725_driver = { 498 .driver = { 499 .name = MCP4725_DRV_NAME, 500 .pm = MCP4725_PM_OPS, 501 }, 502 .probe = mcp4725_probe, 503 .remove = mcp4725_remove, 504 .id_table = mcp4725_id, 505 }; 506 module_i2c_driver(mcp4725_driver); 507 508 MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>"); 509 MODULE_DESCRIPTION("MCP4725/6 12-bit DAC"); 510 MODULE_LICENSE("GPL"); 511