linux/drivers/power/ds2781_battery.c
<<
>>
Prefs
   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, &current_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, &current_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, &current_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 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 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
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.