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