ds2780_battery.c revision 275ac74629c4d8ec430d7edecb16d936f46a47c5
1/* 2 * 1-wire client/driver for the Maxim/Dallas DS2780 Stand-Alone Fuel Gauge IC 3 * 4 * Copyright (C) 2010 Indesign, LLC 5 * 6 * Author: Clifton Barnes <cabarnes@indesign-llc.com> 7 * 8 * Based on ds2760_battery and ds2782_battery drivers 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License version 2 as 12 * published by the Free Software Foundation. 13 * 14 */ 15 16#include <linux/module.h> 17#include <linux/slab.h> 18#include <linux/param.h> 19#include <linux/pm.h> 20#include <linux/platform_device.h> 21#include <linux/power_supply.h> 22#include <linux/idr.h> 23 24#include "../w1/w1.h" 25#include "../w1/slaves/w1_ds2780.h" 26 27/* Current unit measurement in uA for a 1 milli-ohm sense resistor */ 28#define DS2780_CURRENT_UNITS 1563 29/* Charge unit measurement in uAh for a 1 milli-ohm sense resistor */ 30#define DS2780_CHARGE_UNITS 6250 31/* Number of bytes in user EEPROM space */ 32#define DS2780_USER_EEPROM_SIZE (DS2780_EEPROM_BLOCK0_END - \ 33 DS2780_EEPROM_BLOCK0_START + 1) 34/* Number of bytes in parameter EEPROM space */ 35#define DS2780_PARAM_EEPROM_SIZE (DS2780_EEPROM_BLOCK1_END - \ 36 DS2780_EEPROM_BLOCK1_START + 1) 37 38struct ds2780_device_info { 39 struct device *dev; 40 struct power_supply bat; 41 struct device *w1_dev; 42}; 43 44enum current_types { 45 CURRENT_NOW, 46 CURRENT_AVG, 47}; 48 49static const char model[] = "DS2780"; 50static const char manufacturer[] = "Maxim/Dallas"; 51 52static inline struct ds2780_device_info *to_ds2780_device_info( 53 struct power_supply *psy) 54{ 55 return container_of(psy, struct ds2780_device_info, bat); 56} 57 58static inline struct power_supply *to_power_supply(struct device *dev) 59{ 60 return dev_get_drvdata(dev); 61} 62 63static inline int ds2780_read8(struct device *dev, u8 *val, int addr) 64{ 65 return w1_ds2780_io(dev, val, addr, sizeof(u8), 0); 66} 67 68static int ds2780_read16(struct device *dev, s16 *val, int addr) 69{ 70 int ret; 71 u8 raw[2]; 72 73 ret = w1_ds2780_io(dev, raw, addr, sizeof(u8) * 2, 0); 74 if (ret < 0) 75 return ret; 76 77 *val = (raw[0] << 8) | raw[1]; 78 79 return 0; 80} 81 82static inline int ds2780_read_block(struct device *dev, u8 *val, int addr, 83 size_t count) 84{ 85 return w1_ds2780_io(dev, val, addr, count, 0); 86} 87 88static inline int ds2780_write(struct device *dev, u8 *val, int addr, 89 size_t count) 90{ 91 return w1_ds2780_io(dev, val, addr, count, 1); 92} 93 94static inline int ds2780_store_eeprom(struct device *dev, int addr) 95{ 96 return w1_ds2780_eeprom_cmd(dev, addr, W1_DS2780_COPY_DATA); 97} 98 99static inline int ds2780_recall_eeprom(struct device *dev, int addr) 100{ 101 return w1_ds2780_eeprom_cmd(dev, addr, W1_DS2780_RECALL_DATA); 102} 103 104static int ds2780_save_eeprom(struct ds2780_device_info *dev_info, int reg) 105{ 106 int ret; 107 108 ret = ds2780_store_eeprom(dev_info->w1_dev, reg); 109 if (ret < 0) 110 return ret; 111 112 ret = ds2780_recall_eeprom(dev_info->w1_dev, reg); 113 if (ret < 0) 114 return ret; 115 116 return 0; 117} 118 119/* Set sense resistor value in mhos */ 120static int ds2780_set_sense_register(struct ds2780_device_info *dev_info, 121 u8 conductance) 122{ 123 int ret; 124 125 ret = ds2780_write(dev_info->w1_dev, &conductance, 126 DS2780_RSNSP_REG, sizeof(u8)); 127 if (ret < 0) 128 return ret; 129 130 return ds2780_save_eeprom(dev_info, DS2780_RSNSP_REG); 131} 132 133/* Get RSGAIN value from 0 to 1.999 in steps of 0.001 */ 134static int ds2780_get_rsgain_register(struct ds2780_device_info *dev_info, 135 u16 *rsgain) 136{ 137 return ds2780_read16(dev_info->w1_dev, rsgain, DS2780_RSGAIN_MSB_REG); 138} 139 140/* Set RSGAIN value from 0 to 1.999 in steps of 0.001 */ 141static int ds2780_set_rsgain_register(struct ds2780_device_info *dev_info, 142 u16 rsgain) 143{ 144 int ret; 145 u8 raw[] = {rsgain >> 8, rsgain & 0xFF}; 146 147 ret = ds2780_write(dev_info->w1_dev, raw, 148 DS2780_RSGAIN_MSB_REG, sizeof(u8) * 2); 149 if (ret < 0) 150 return ret; 151 152 return ds2780_save_eeprom(dev_info, DS2780_RSGAIN_MSB_REG); 153} 154 155static int ds2780_get_voltage(struct ds2780_device_info *dev_info, 156 int *voltage_uV) 157{ 158 int ret; 159 s16 voltage_raw; 160 161 /* 162 * The voltage value is located in 10 bits across the voltage MSB 163 * and LSB registers in two's compliment form 164 * Sign bit of the voltage value is in bit 7 of the voltage MSB register 165 * Bits 9 - 3 of the voltage value are in bits 6 - 0 of the 166 * voltage MSB register 167 * Bits 2 - 0 of the voltage value are in bits 7 - 5 of the 168 * voltage LSB register 169 */ 170 ret = ds2780_read16(dev_info->w1_dev, &voltage_raw, 171 DS2780_VOLT_MSB_REG); 172 if (ret < 0) 173 return ret; 174 175 /* 176 * DS2780 reports voltage in units of 4.88mV, but the battery class 177 * reports in units of uV, so convert by multiplying by 4880. 178 */ 179 *voltage_uV = (voltage_raw / 32) * 4880; 180 return 0; 181} 182 183static int ds2780_get_temperature(struct ds2780_device_info *dev_info, 184 int *temperature) 185{ 186 int ret; 187 s16 temperature_raw; 188 189 /* 190 * The temperature value is located in 10 bits across the temperature 191 * MSB and LSB registers in two's compliment form 192 * Sign bit of the temperature value is in bit 7 of the temperature 193 * MSB register 194 * Bits 9 - 3 of the temperature value are in bits 6 - 0 of the 195 * temperature MSB register 196 * Bits 2 - 0 of the temperature value are in bits 7 - 5 of the 197 * temperature LSB register 198 */ 199 ret = ds2780_read16(dev_info->w1_dev, &temperature_raw, 200 DS2780_TEMP_MSB_REG); 201 if (ret < 0) 202 return ret; 203 204 /* 205 * Temperature is measured in units of 0.125 degrees celcius, the 206 * power_supply class measures temperature in tenths of degrees 207 * celsius. The temperature value is stored as a 10 bit number, plus 208 * sign in the upper bits of a 16 bit register. 209 */ 210 *temperature = ((temperature_raw / 32) * 125) / 100; 211 return 0; 212} 213 214static int ds2780_get_current(struct ds2780_device_info *dev_info, 215 enum current_types type, int *current_uA) 216{ 217 int ret, sense_res; 218 s16 current_raw; 219 u8 sense_res_raw, reg_msb; 220 221 /* 222 * The units of measurement for current are dependent on the value of 223 * the sense resistor. 224 */ 225 ret = ds2780_read8(dev_info->w1_dev, &sense_res_raw, DS2780_RSNSP_REG); 226 if (ret < 0) 227 return ret; 228 229 if (sense_res_raw == 0) { 230 dev_err(dev_info->dev, "sense resistor value is 0\n"); 231 return -ENXIO; 232 } 233 sense_res = 1000 / sense_res_raw; 234 235 if (type == CURRENT_NOW) 236 reg_msb = DS2780_CURRENT_MSB_REG; 237 else if (type == CURRENT_AVG) 238 reg_msb = DS2780_IAVG_MSB_REG; 239 else 240 return -EINVAL; 241 242 /* 243 * The current value is located in 16 bits across the current MSB 244 * and LSB registers in two's compliment form 245 * Sign bit of the current value is in bit 7 of the current MSB register 246 * Bits 14 - 8 of the current value are in bits 6 - 0 of the current 247 * MSB register 248 * Bits 7 - 0 of the current value are in bits 7 - 0 of the current 249 * LSB register 250 */ 251 ret = ds2780_read16(dev_info->w1_dev, ¤t_raw, reg_msb); 252 if (ret < 0) 253 return ret; 254 255 *current_uA = current_raw * (DS2780_CURRENT_UNITS / sense_res); 256 return 0; 257} 258 259static int ds2780_get_accumulated_current(struct ds2780_device_info *dev_info, 260 int *accumulated_current) 261{ 262 int ret, sense_res; 263 s16 current_raw; 264 u8 sense_res_raw; 265 266 /* 267 * The units of measurement for accumulated current are dependent on 268 * the value of the sense resistor. 269 */ 270 ret = ds2780_read8(dev_info->w1_dev, &sense_res_raw, DS2780_RSNSP_REG); 271 if (ret < 0) 272 return ret; 273 274 if (sense_res_raw == 0) { 275 dev_err(dev_info->dev, "sense resistor value is 0\n"); 276 return -ENXIO; 277 } 278 sense_res = 1000 / sense_res_raw; 279 280 /* 281 * The ACR value is located in 16 bits across the ACR MSB and 282 * LSB registers 283 * Bits 15 - 8 of the ACR value are in bits 7 - 0 of the ACR 284 * MSB register 285 * Bits 7 - 0 of the ACR value are in bits 7 - 0 of the ACR 286 * LSB register 287 */ 288 ret = ds2780_read16(dev_info->w1_dev, ¤t_raw, DS2780_ACR_MSB_REG); 289 if (ret < 0) 290 return ret; 291 292 *accumulated_current = current_raw * (DS2780_CHARGE_UNITS / sense_res); 293 return 0; 294} 295 296static int ds2780_get_capacity(struct ds2780_device_info *dev_info, 297 int *capacity) 298{ 299 int ret; 300 u8 raw; 301 302 ret = ds2780_read8(dev_info->w1_dev, &raw, DS2780_RARC_REG); 303 if (ret < 0) 304 return ret; 305 306 *capacity = raw; 307 return raw; 308} 309 310static int ds2780_get_status(struct ds2780_device_info *dev_info, int *status) 311{ 312 int ret, current_uA, capacity; 313 314 ret = ds2780_get_current(dev_info, CURRENT_NOW, ¤t_uA); 315 if (ret < 0) 316 return ret; 317 318 ret = ds2780_get_capacity(dev_info, &capacity); 319 if (ret < 0) 320 return ret; 321 322 if (capacity == 100) 323 *status = POWER_SUPPLY_STATUS_FULL; 324 else if (current_uA == 0) 325 *status = POWER_SUPPLY_STATUS_NOT_CHARGING; 326 else if (current_uA < 0) 327 *status = POWER_SUPPLY_STATUS_DISCHARGING; 328 else 329 *status = POWER_SUPPLY_STATUS_CHARGING; 330 331 return 0; 332} 333 334static int ds2780_get_charge_now(struct ds2780_device_info *dev_info, 335 int *charge_now) 336{ 337 int ret; 338 u16 charge_raw; 339 340 /* 341 * The RAAC value is located in 16 bits across the RAAC MSB and 342 * LSB registers 343 * Bits 15 - 8 of the RAAC value are in bits 7 - 0 of the RAAC 344 * MSB register 345 * Bits 7 - 0 of the RAAC value are in bits 7 - 0 of the RAAC 346 * LSB register 347 */ 348 ret = ds2780_read16(dev_info->w1_dev, &charge_raw, DS2780_RAAC_MSB_REG); 349 if (ret < 0) 350 return ret; 351 352 *charge_now = charge_raw * 1600; 353 return 0; 354} 355 356static int ds2780_get_control_register(struct ds2780_device_info *dev_info, 357 u8 *control_reg) 358{ 359 return ds2780_read8(dev_info->w1_dev, control_reg, DS2780_CONTROL_REG); 360} 361 362static int ds2780_set_control_register(struct ds2780_device_info *dev_info, 363 u8 control_reg) 364{ 365 int ret; 366 367 ret = ds2780_write(dev_info->w1_dev, &control_reg, 368 DS2780_CONTROL_REG, sizeof(u8)); 369 if (ret < 0) 370 return ret; 371 372 return ds2780_save_eeprom(dev_info, DS2780_CONTROL_REG); 373} 374 375static int ds2780_battery_get_property(struct power_supply *psy, 376 enum power_supply_property psp, 377 union power_supply_propval *val) 378{ 379 int ret = 0; 380 struct ds2780_device_info *dev_info = to_ds2780_device_info(psy); 381 382 switch (psp) { 383 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 384 ret = ds2780_get_voltage(dev_info, &val->intval); 385 break; 386 387 case POWER_SUPPLY_PROP_TEMP: 388 ret = ds2780_get_temperature(dev_info, &val->intval); 389 break; 390 391 case POWER_SUPPLY_PROP_MODEL_NAME: 392 val->strval = model; 393 break; 394 395 case POWER_SUPPLY_PROP_MANUFACTURER: 396 val->strval = manufacturer; 397 break; 398 399 case POWER_SUPPLY_PROP_CURRENT_NOW: 400 ret = ds2780_get_current(dev_info, CURRENT_NOW, &val->intval); 401 break; 402 403 case POWER_SUPPLY_PROP_CURRENT_AVG: 404 ret = ds2780_get_current(dev_info, CURRENT_AVG, &val->intval); 405 break; 406 407 case POWER_SUPPLY_PROP_STATUS: 408 ret = ds2780_get_status(dev_info, &val->intval); 409 break; 410 411 case POWER_SUPPLY_PROP_CAPACITY: 412 ret = ds2780_get_capacity(dev_info, &val->intval); 413 break; 414 415 case POWER_SUPPLY_PROP_CHARGE_COUNTER: 416 ret = ds2780_get_accumulated_current(dev_info, &val->intval); 417 break; 418 419 case POWER_SUPPLY_PROP_CHARGE_NOW: 420 ret = ds2780_get_charge_now(dev_info, &val->intval); 421 break; 422 423 default: 424 ret = -EINVAL; 425 } 426 427 return ret; 428} 429 430static enum power_supply_property ds2780_battery_props[] = { 431 POWER_SUPPLY_PROP_STATUS, 432 POWER_SUPPLY_PROP_VOLTAGE_NOW, 433 POWER_SUPPLY_PROP_TEMP, 434 POWER_SUPPLY_PROP_MODEL_NAME, 435 POWER_SUPPLY_PROP_MANUFACTURER, 436 POWER_SUPPLY_PROP_CURRENT_NOW, 437 POWER_SUPPLY_PROP_CURRENT_AVG, 438 POWER_SUPPLY_PROP_CAPACITY, 439 POWER_SUPPLY_PROP_CHARGE_COUNTER, 440 POWER_SUPPLY_PROP_CHARGE_NOW, 441}; 442 443static ssize_t ds2780_get_pmod_enabled(struct device *dev, 444 struct device_attribute *attr, 445 char *buf) 446{ 447 int ret; 448 u8 control_reg; 449 struct power_supply *psy = to_power_supply(dev); 450 struct ds2780_device_info *dev_info = to_ds2780_device_info(psy); 451 452 /* Get power mode */ 453 ret = ds2780_get_control_register(dev_info, &control_reg); 454 if (ret < 0) 455 return ret; 456 457 return sprintf(buf, "%d\n", 458 !!(control_reg & DS2780_CONTROL_REG_PMOD)); 459} 460 461static ssize_t ds2780_set_pmod_enabled(struct device *dev, 462 struct device_attribute *attr, 463 const char *buf, 464 size_t count) 465{ 466 int ret; 467 u8 control_reg, new_setting; 468 struct power_supply *psy = to_power_supply(dev); 469 struct ds2780_device_info *dev_info = to_ds2780_device_info(psy); 470 471 /* Set power mode */ 472 ret = ds2780_get_control_register(dev_info, &control_reg); 473 if (ret < 0) 474 return ret; 475 476 ret = kstrtou8(buf, 0, &new_setting); 477 if (ret < 0) 478 return ret; 479 480 if ((new_setting != 0) && (new_setting != 1)) { 481 dev_err(dev_info->dev, "Invalid pmod setting (0 or 1)\n"); 482 return -EINVAL; 483 } 484 485 if (new_setting) 486 control_reg |= DS2780_CONTROL_REG_PMOD; 487 else 488 control_reg &= ~DS2780_CONTROL_REG_PMOD; 489 490 ret = ds2780_set_control_register(dev_info, control_reg); 491 if (ret < 0) 492 return ret; 493 494 return count; 495} 496 497static ssize_t ds2780_get_sense_resistor_value(struct device *dev, 498 struct device_attribute *attr, 499 char *buf) 500{ 501 int ret; 502 u8 sense_resistor; 503 struct power_supply *psy = to_power_supply(dev); 504 struct ds2780_device_info *dev_info = to_ds2780_device_info(psy); 505 506 ret = ds2780_read8(dev_info->w1_dev, &sense_resistor, DS2780_RSNSP_REG); 507 if (ret < 0) 508 return ret; 509 510 ret = sprintf(buf, "%d\n", sense_resistor); 511 return ret; 512} 513 514static ssize_t ds2780_set_sense_resistor_value(struct device *dev, 515 struct device_attribute *attr, 516 const char *buf, 517 size_t count) 518{ 519 int ret; 520 u8 new_setting; 521 struct power_supply *psy = to_power_supply(dev); 522 struct ds2780_device_info *dev_info = to_ds2780_device_info(psy); 523 524 ret = kstrtou8(buf, 0, &new_setting); 525 if (ret < 0) 526 return ret; 527 528 ret = ds2780_set_sense_register(dev_info, new_setting); 529 if (ret < 0) 530 return ret; 531 532 return count; 533} 534 535static ssize_t ds2780_get_rsgain_setting(struct device *dev, 536 struct device_attribute *attr, 537 char *buf) 538{ 539 int ret; 540 u16 rsgain; 541 struct power_supply *psy = to_power_supply(dev); 542 struct ds2780_device_info *dev_info = to_ds2780_device_info(psy); 543 544 ret = ds2780_get_rsgain_register(dev_info, &rsgain); 545 if (ret < 0) 546 return ret; 547 548 return sprintf(buf, "%d\n", rsgain); 549} 550 551static ssize_t ds2780_set_rsgain_setting(struct device *dev, 552 struct device_attribute *attr, 553 const char *buf, 554 size_t count) 555{ 556 int ret; 557 u16 new_setting; 558 struct power_supply *psy = to_power_supply(dev); 559 struct ds2780_device_info *dev_info = to_ds2780_device_info(psy); 560 561 ret = kstrtou16(buf, 0, &new_setting); 562 if (ret < 0) 563 return ret; 564 565 /* Gain can only be from 0 to 1.999 in steps of .001 */ 566 if (new_setting > 1999) { 567 dev_err(dev_info->dev, "Invalid rsgain setting (0 - 1999)\n"); 568 return -EINVAL; 569 } 570 571 ret = ds2780_set_rsgain_register(dev_info, new_setting); 572 if (ret < 0) 573 return ret; 574 575 return count; 576} 577 578static ssize_t ds2780_get_pio_pin(struct device *dev, 579 struct device_attribute *attr, 580 char *buf) 581{ 582 int ret; 583 u8 sfr; 584 struct power_supply *psy = to_power_supply(dev); 585 struct ds2780_device_info *dev_info = to_ds2780_device_info(psy); 586 587 ret = ds2780_read8(dev_info->w1_dev, &sfr, DS2780_SFR_REG); 588 if (ret < 0) 589 return ret; 590 591 ret = sprintf(buf, "%d\n", sfr & DS2780_SFR_REG_PIOSC); 592 return ret; 593} 594 595static ssize_t ds2780_set_pio_pin(struct device *dev, 596 struct device_attribute *attr, 597 const char *buf, 598 size_t count) 599{ 600 int ret; 601 u8 new_setting; 602 struct power_supply *psy = to_power_supply(dev); 603 struct ds2780_device_info *dev_info = to_ds2780_device_info(psy); 604 605 ret = kstrtou8(buf, 0, &new_setting); 606 if (ret < 0) 607 return ret; 608 609 if ((new_setting != 0) && (new_setting != 1)) { 610 dev_err(dev_info->dev, "Invalid pio_pin setting (0 or 1)\n"); 611 return -EINVAL; 612 } 613 614 ret = ds2780_write(dev_info->w1_dev, &new_setting, 615 DS2780_SFR_REG, sizeof(u8)); 616 if (ret < 0) 617 return ret; 618 619 return count; 620} 621 622static ssize_t ds2780_read_param_eeprom_bin(struct file *filp, 623 struct kobject *kobj, 624 struct bin_attribute *bin_attr, 625 char *buf, loff_t off, size_t count) 626{ 627 struct device *dev = container_of(kobj, struct device, kobj); 628 struct power_supply *psy = to_power_supply(dev); 629 struct ds2780_device_info *dev_info = to_ds2780_device_info(psy); 630 631 count = min_t(loff_t, count, 632 DS2780_EEPROM_BLOCK1_END - 633 DS2780_EEPROM_BLOCK1_START + 1 - off); 634 635 return ds2780_read_block(dev_info->w1_dev, buf, 636 DS2780_EEPROM_BLOCK1_START + off, count); 637} 638 639static ssize_t ds2780_write_param_eeprom_bin(struct file *filp, 640 struct kobject *kobj, 641 struct bin_attribute *bin_attr, 642 char *buf, loff_t off, size_t count) 643{ 644 struct device *dev = container_of(kobj, struct device, kobj); 645 struct power_supply *psy = to_power_supply(dev); 646 struct ds2780_device_info *dev_info = to_ds2780_device_info(psy); 647 int ret; 648 649 count = min_t(loff_t, count, 650 DS2780_EEPROM_BLOCK1_END - 651 DS2780_EEPROM_BLOCK1_START + 1 - off); 652 653 ret = ds2780_write(dev_info->w1_dev, buf, 654 DS2780_EEPROM_BLOCK1_START + off, count); 655 if (ret < 0) 656 return ret; 657 658 ret = ds2780_save_eeprom(dev_info, DS2780_EEPROM_BLOCK1_START); 659 if (ret < 0) 660 return ret; 661 662 return count; 663} 664 665static struct bin_attribute ds2780_param_eeprom_bin_attr = { 666 .attr = { 667 .name = "param_eeprom", 668 .mode = S_IRUGO | S_IWUSR, 669 }, 670 .size = DS2780_EEPROM_BLOCK1_END - DS2780_EEPROM_BLOCK1_START + 1, 671 .read = ds2780_read_param_eeprom_bin, 672 .write = ds2780_write_param_eeprom_bin, 673}; 674 675static ssize_t ds2780_read_user_eeprom_bin(struct file *filp, 676 struct kobject *kobj, 677 struct bin_attribute *bin_attr, 678 char *buf, loff_t off, size_t count) 679{ 680 struct device *dev = container_of(kobj, struct device, kobj); 681 struct power_supply *psy = to_power_supply(dev); 682 struct ds2780_device_info *dev_info = to_ds2780_device_info(psy); 683 684 count = min_t(loff_t, count, 685 DS2780_EEPROM_BLOCK0_END - 686 DS2780_EEPROM_BLOCK0_START + 1 - off); 687 688 return ds2780_read_block(dev_info->w1_dev, buf, 689 DS2780_EEPROM_BLOCK0_START + off, count); 690 691} 692 693static ssize_t ds2780_write_user_eeprom_bin(struct file *filp, 694 struct kobject *kobj, 695 struct bin_attribute *bin_attr, 696 char *buf, loff_t off, size_t count) 697{ 698 struct device *dev = container_of(kobj, struct device, kobj); 699 struct power_supply *psy = to_power_supply(dev); 700 struct ds2780_device_info *dev_info = to_ds2780_device_info(psy); 701 int ret; 702 703 count = min_t(loff_t, count, 704 DS2780_EEPROM_BLOCK0_END - 705 DS2780_EEPROM_BLOCK0_START + 1 - off); 706 707 ret = ds2780_write(dev_info->w1_dev, buf, 708 DS2780_EEPROM_BLOCK0_START + off, count); 709 if (ret < 0) 710 return ret; 711 712 ret = ds2780_save_eeprom(dev_info, DS2780_EEPROM_BLOCK0_START); 713 if (ret < 0) 714 return ret; 715 716 return count; 717} 718 719static struct bin_attribute ds2780_user_eeprom_bin_attr = { 720 .attr = { 721 .name = "user_eeprom", 722 .mode = S_IRUGO | S_IWUSR, 723 }, 724 .size = DS2780_EEPROM_BLOCK0_END - DS2780_EEPROM_BLOCK0_START + 1, 725 .read = ds2780_read_user_eeprom_bin, 726 .write = ds2780_write_user_eeprom_bin, 727}; 728 729static DEVICE_ATTR(pmod_enabled, S_IRUGO | S_IWUSR, ds2780_get_pmod_enabled, 730 ds2780_set_pmod_enabled); 731static DEVICE_ATTR(sense_resistor_value, S_IRUGO | S_IWUSR, 732 ds2780_get_sense_resistor_value, ds2780_set_sense_resistor_value); 733static DEVICE_ATTR(rsgain_setting, S_IRUGO | S_IWUSR, ds2780_get_rsgain_setting, 734 ds2780_set_rsgain_setting); 735static DEVICE_ATTR(pio_pin, S_IRUGO | S_IWUSR, ds2780_get_pio_pin, 736 ds2780_set_pio_pin); 737 738 739static struct attribute *ds2780_attributes[] = { 740 &dev_attr_pmod_enabled.attr, 741 &dev_attr_sense_resistor_value.attr, 742 &dev_attr_rsgain_setting.attr, 743 &dev_attr_pio_pin.attr, 744 NULL 745}; 746 747static const struct attribute_group ds2780_attr_group = { 748 .attrs = ds2780_attributes, 749}; 750 751static int __devinit ds2780_battery_probe(struct platform_device *pdev) 752{ 753 int ret = 0; 754 struct ds2780_device_info *dev_info; 755 756 dev_info = kzalloc(sizeof(*dev_info), GFP_KERNEL); 757 if (!dev_info) { 758 ret = -ENOMEM; 759 goto fail; 760 } 761 762 platform_set_drvdata(pdev, dev_info); 763 764 dev_info->dev = &pdev->dev; 765 dev_info->w1_dev = pdev->dev.parent; 766 dev_info->bat.name = dev_name(&pdev->dev); 767 dev_info->bat.type = POWER_SUPPLY_TYPE_BATTERY; 768 dev_info->bat.properties = ds2780_battery_props; 769 dev_info->bat.num_properties = ARRAY_SIZE(ds2780_battery_props); 770 dev_info->bat.get_property = ds2780_battery_get_property; 771 772 ret = power_supply_register(&pdev->dev, &dev_info->bat); 773 if (ret) { 774 dev_err(dev_info->dev, "failed to register battery\n"); 775 goto fail_free_info; 776 } 777 778 ret = sysfs_create_group(&dev_info->bat.dev->kobj, &ds2780_attr_group); 779 if (ret) { 780 dev_err(dev_info->dev, "failed to create sysfs group\n"); 781 goto fail_unregister; 782 } 783 784 ret = sysfs_create_bin_file(&dev_info->bat.dev->kobj, 785 &ds2780_param_eeprom_bin_attr); 786 if (ret) { 787 dev_err(dev_info->dev, 788 "failed to create param eeprom bin file"); 789 goto fail_remove_group; 790 } 791 792 ret = sysfs_create_bin_file(&dev_info->bat.dev->kobj, 793 &ds2780_user_eeprom_bin_attr); 794 if (ret) { 795 dev_err(dev_info->dev, 796 "failed to create user eeprom bin file"); 797 goto fail_remove_bin_file; 798 } 799 800 return 0; 801 802fail_remove_bin_file: 803 sysfs_remove_bin_file(&dev_info->bat.dev->kobj, 804 &ds2780_param_eeprom_bin_attr); 805fail_remove_group: 806 sysfs_remove_group(&dev_info->bat.dev->kobj, &ds2780_attr_group); 807fail_unregister: 808 power_supply_unregister(&dev_info->bat); 809fail_free_info: 810 kfree(dev_info); 811fail: 812 return ret; 813} 814 815static int __devexit ds2780_battery_remove(struct platform_device *pdev) 816{ 817 struct ds2780_device_info *dev_info = platform_get_drvdata(pdev); 818 819 /* remove attributes */ 820 sysfs_remove_group(&dev_info->bat.dev->kobj, &ds2780_attr_group); 821 822 power_supply_unregister(&dev_info->bat); 823 824 kfree(dev_info); 825 return 0; 826} 827 828MODULE_ALIAS("platform:ds2780-battery"); 829 830static struct platform_driver ds2780_battery_driver = { 831 .driver = { 832 .name = "ds2780-battery", 833 }, 834 .probe = ds2780_battery_probe, 835 .remove = ds2780_battery_remove, 836}; 837 838static int __init ds2780_battery_init(void) 839{ 840 return platform_driver_register(&ds2780_battery_driver); 841} 842 843static void __exit ds2780_battery_exit(void) 844{ 845 platform_driver_unregister(&ds2780_battery_driver); 846} 847 848module_init(ds2780_battery_init); 849module_exit(ds2780_battery_exit); 850 851MODULE_LICENSE("GPL"); 852MODULE_AUTHOR("Clifton Barnes <cabarnes@indesign-llc.com>"); 853MODULE_DESCRIPTION("Maxim/Dallas DS2780 Stand-Alone Fuel Gauage IC driver"); 854