drivers/power/supply/sbs-manager.c

   1 /*
   2  * Driver for SBS compliant Smart Battery System Managers
   3  *
   4  * The device communicates via i2c at address 0x0a and multiplexes access to up
   5  * to four smart batteries at address 0x0b.
   6  *
   7  * Via sysfs interface the online state and charge type are presented.
   8  *
   9  * Datasheet SBSM:    http://sbs-forum.org/specs/sbsm100b.pdf
  10  * Datasheet LTC1760: http://cds.linear.com/docs/en/datasheet/1760fb.pdf
  11  *
  12  * Karl-Heinz Schneider <karl-heinz@schneider-inet.de>
  13  *
  14  * This program is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License version 2 as
  16  * published by the Free Software Foundation.
  17  */
  18
  19 #include <linux/gpio.h>
  20 #include <linux/module.h>
  21 #include <linux/i2c.h>
  22 #include <linux/i2c-mux.h>
  23 #include <linux/power_supply.h>
  24 #include <linux/property.h>
  25
  26 #define SBSM_MAX_BATS  4
  27 #define SBSM_RETRY_CNT 3
  28
  29 /* registers addresses */
  30 #define SBSM_CMD_BATSYSSTATE     0x01
  31 #define SBSM_CMD_BATSYSSTATECONT 0x02
  32 #define SBSM_CMD_BATSYSINFO      0x04
  33 #define SBSM_CMD_LTC             0x3c
  34
  35 #define SBSM_MASK_BAT_SUPPORTED  GENMASK(3, 0)
  36 #define SBSM_MASK_CHARGE_BAT     GENMASK(7, 4)
  37 #define SBSM_BIT_AC_PRESENT      BIT(0)
  38 #define SBSM_BIT_TURBO           BIT(7)
  39
  40 #define SBSM_SMB_BAT_OFFSET      11
  41 struct sbsm_data {
  42         struct i2c_client *client;
  43         struct i2c_mux_core *muxc;
  44
  45         struct power_supply *psy;
  46
  47         u8 cur_chan;          /* currently selected channel */
  48         struct gpio_chip chip;
  49         bool is_ltc1760;      /* special capabilities */
  50
  51         unsigned int supported_bats;
  52         unsigned int last_state;
  53         unsigned int last_state_cont;
  54 };
  55
  56 static enum power_supply_property sbsm_props[] = {
  57         POWER_SUPPLY_PROP_ONLINE,
  58         POWER_SUPPLY_PROP_CHARGE_TYPE,
  59 };
  60
  61 static int sbsm_read_word(struct i2c_client *client, u8 address)
  62 {
  63         int reg, retries;
  64
  65         for (retries = SBSM_RETRY_CNT; retries > 0; retries--) {
  66                 reg = i2c_smbus_read_word_data(client, address);
  67                 if (reg >= 0)
  68                         break;
  69         }
  70
  71         if (reg < 0) {
  72                 dev_err(&client->dev, "failed to read register 0x%02x\n",
  73                         address);
  74         }
  75
  76         return reg;
  77 }
  78
  79 static int sbsm_write_word(struct i2c_client *client, u8 address, u16 word)
  80 {
  81         int ret, retries;
  82
  83         for (retries = SBSM_RETRY_CNT; retries > 0; retries--) {
  84                 ret = i2c_smbus_write_word_data(client, address, word);
  85                 if (ret >= 0)
  86                         break;
  87         }
  88         if (ret < 0)
  89                 dev_err(&client->dev, "failed to write to register 0x%02x\n",
  90                         address);
  91
  92         return ret;
  93 }
  94
  95 static int sbsm_get_property(struct power_supply *psy,
  96                              enum power_supply_property psp,
  97                              union power_supply_propval *val)
  98 {
  99         struct sbsm_data *data = power_supply_get_drvdata(psy);
 100         int regval = 0;
 101
 102         switch (psp) {
 103         case POWER_SUPPLY_PROP_ONLINE:
 104                 regval = sbsm_read_word(data->client, SBSM_CMD_BATSYSSTATECONT);
 105                 if (regval < 0)
 106                         return regval;
 107                 val->intval = !!(regval & SBSM_BIT_AC_PRESENT);
 108                 break;
 109
 110         case POWER_SUPPLY_PROP_CHARGE_TYPE:
 111                 regval = sbsm_read_word(data->client, SBSM_CMD_BATSYSSTATE);
 112                 if (regval < 0)
 113                         return regval;
 114
 115                 if ((regval & SBSM_MASK_CHARGE_BAT) == 0) {
 116                         val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
 117                         return 0;
 118                 }
 119                 val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
 120
 121                 if (data->is_ltc1760) {
 122                         /* charge mode fast if turbo is active */
 123                         regval = sbsm_read_word(data->client, SBSM_CMD_LTC);
 124                         if (regval < 0)
 125                                 return regval;
 126                         else if (regval & SBSM_BIT_TURBO)
 127                                 val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
 128                 }
 129                 break;
 130
 131         default:
 132                 return -EINVAL;
 133         }
 134
 135         return 0;
 136 }
 137
 138 static int sbsm_prop_is_writeable(struct power_supply *psy,
 139                                   enum power_supply_property psp)
 140 {
 141         struct sbsm_data *data = power_supply_get_drvdata(psy);
 142
 143         return (psp == POWER_SUPPLY_PROP_CHARGE_TYPE) && data->is_ltc1760;
 144 }
 145
 146 static int sbsm_set_property(struct power_supply *psy,
 147                              enum power_supply_property psp,
 148                              const union power_supply_propval *val)
 149 {
 150         struct sbsm_data *data = power_supply_get_drvdata(psy);
 151         int ret = -EINVAL;
 152         u16 regval;
 153
 154         switch (psp) {
 155         case POWER_SUPPLY_PROP_CHARGE_TYPE:
 156                 /* write 1 to TURBO if type fast is given */
 157                 if (!data->is_ltc1760)
 158                         break;
 159                 regval = val->intval ==
 160                          POWER_SUPPLY_CHARGE_TYPE_FAST ? SBSM_BIT_TURBO : 0;
 161                 ret = sbsm_write_word(data->client, SBSM_CMD_LTC, regval);
 162                 break;
 163
 164         default:
 165                 break;
 166         }
 167
 168         return ret;
 169 }
 170
 171 /*
 172  * Switch to battery
 173  * Parameter chan is directly the content of SMB_BAT* nibble
 174  */
 175 static int sbsm_select(struct i2c_mux_core *muxc, u32 chan)
 176 {
 177         struct sbsm_data *data = i2c_mux_priv(muxc);
 178         struct device *dev = &data->client->dev;
 179         int ret = 0;
 180         u16 reg;
 181
 182         if (data->cur_chan == chan)
 183                 return ret;
 184
 185         /* chan goes from 1 ... 4 */
 186         reg = BIT(SBSM_SMB_BAT_OFFSET + chan);
 187         ret = sbsm_write_word(data->client, SBSM_CMD_BATSYSSTATE, reg);
 188         if (ret)
 189                 dev_err(dev, "Failed to select channel %i\n", chan);
 190         else
 191                 data->cur_chan = chan;
 192
 193         return ret;
 194 }
 195
 196 static int sbsm_gpio_get_value(struct gpio_chip *gc, unsigned int off)
 197 {
 198         struct sbsm_data *data = gpiochip_get_data(gc);
 199         int ret;
 200
 201         ret = sbsm_read_word(data->client, SBSM_CMD_BATSYSSTATE);
 202         if (ret < 0)
 203                 return ret;
 204
 205         return ret & BIT(off);
 206 }
 207
 208 /*
 209  * This needs to be defined or the GPIO lib fails to register the pin.
 210  * But the 'gpio' is always an input.
 211  */
 212 static int sbsm_gpio_direction_input(struct gpio_chip *gc, unsigned int off)
 213 {
 214         return 0;
 215 }
 216
 217 static int sbsm_do_alert(struct device *dev, void *d)
 218 {
 219         struct i2c_client *client = i2c_verify_client(dev);
 220         struct i2c_driver *driver;
 221
 222         if (!client || client->addr != 0x0b)
 223                 return 0;
 224
 225         device_lock(dev);
 226         if (client->dev.driver) {
 227                 driver = to_i2c_driver(client->dev.driver);
 228                 if (driver->alert)
 229                         driver->alert(client, I2C_PROTOCOL_SMBUS_ALERT, 0);
 230                 else
 231                         dev_warn(&client->dev, "no driver alert()!\n");
 232         } else {
 233                 dev_dbg(&client->dev, "alert with no driver\n");
 234         }
 235         device_unlock(dev);
 236
 237         return -EBUSY;
 238 }
 239
 240 static void sbsm_alert(struct i2c_client *client, enum i2c_alert_protocol prot,
 241                        unsigned int d)
 242 {
 243         struct sbsm_data *sbsm = i2c_get_clientdata(client);
 244
 245         int ret, i, irq_bat = 0, state = 0;
 246
 247         ret = sbsm_read_word(sbsm->client, SBSM_CMD_BATSYSSTATE);
 248         if (ret >= 0) {
 249                 irq_bat = ret ^ sbsm->last_state;
 250                 sbsm->last_state = ret;
 251                 state = ret;
 252         }
 253
 254         ret = sbsm_read_word(sbsm->client, SBSM_CMD_BATSYSSTATECONT);
 255         if ((ret >= 0) &&
 256             ((ret ^ sbsm->last_state_cont) & SBSM_BIT_AC_PRESENT)) {
 257                 irq_bat |= sbsm->supported_bats & state;
 258                 power_supply_changed(sbsm->psy);
 259         }
 260         sbsm->last_state_cont = ret;
 261
 262         for (i = 0; i < SBSM_MAX_BATS; i++) {
 263                 if (irq_bat & BIT(i)) {
 264                         device_for_each_child(&sbsm->muxc->adapter[i]->dev,
 265                                               NULL, sbsm_do_alert);
 266                 }
 267         }
 268 }
 269
 270 static int sbsm_gpio_setup(struct sbsm_data *data)
 271 {
 272         struct gpio_chip *gc = &data->chip;
 273         struct i2c_client *client = data->client;
 274         struct device *dev = &client->dev;
 275         int ret;
 276
 277         if (!device_property_present(dev, "gpio-controller"))
 278                 return 0;
 279
 280         ret  = sbsm_read_word(client, SBSM_CMD_BATSYSSTATE);
 281         if (ret < 0)
 282                 return ret;
 283         data->last_state = ret;
 284
 285         ret  = sbsm_read_word(client, SBSM_CMD_BATSYSSTATECONT);
 286         if (ret < 0)
 287                 return ret;
 288         data->last_state_cont = ret;
 289
 290         gc->get = sbsm_gpio_get_value;
 291         gc->direction_input  = sbsm_gpio_direction_input;
 292         gc->can_sleep = true;
 293         gc->base = -1;
 294         gc->ngpio = SBSM_MAX_BATS;
 295         gc->label = client->name;
 296         gc->parent = dev;
 297         gc->owner = THIS_MODULE;
 298
 299         ret = devm_gpiochip_add_data(dev, gc, data);
 300         if (ret) {
 301                 dev_err(dev, "devm_gpiochip_add_data failed: %d\n", ret);
 302                 return ret;
 303         }
 304
 305         return ret;
 306 }
 307
 308 static const struct power_supply_desc sbsm_default_psy_desc = {
 309         .type = POWER_SUPPLY_TYPE_MAINS,
 310         .properties = sbsm_props,
 311         .num_properties = ARRAY_SIZE(sbsm_props),
 312         .get_property = &sbsm_get_property,
 313         .set_property = &sbsm_set_property,
 314         .property_is_writeable = &sbsm_prop_is_writeable,
 315 };
 316
 317 static int sbsm_probe(struct i2c_client *client,
 318                       const struct i2c_device_id *id)
 319 {
 320         struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
 321         struct sbsm_data *data;
 322         struct device *dev = &client->dev;
 323         struct power_supply_desc *psy_desc;
 324         struct power_supply_config psy_cfg = {};
 325         int ret = 0, i;
 326
 327         /* Device listens only at address 0x0a */
 328         if (client->addr != 0x0a)
 329                 return -EINVAL;
 330
 331         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA))
 332                 return -EPFNOSUPPORT;
 333
 334         data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
 335         if (!data)
 336                 return -ENOMEM;
 337
 338         i2c_set_clientdata(client, data);
 339
 340         data->client = client;
 341         data->is_ltc1760 = !!strstr(id->name, "ltc1760");
 342
 343         ret  = sbsm_read_word(client, SBSM_CMD_BATSYSINFO);
 344         if (ret < 0)
 345                 return ret;
 346         data->supported_bats = ret & SBSM_MASK_BAT_SUPPORTED;
 347         data->muxc = i2c_mux_alloc(adapter, dev, SBSM_MAX_BATS, 0,
 348                                    I2C_MUX_LOCKED, &sbsm_select, NULL);
 349         if (!data->muxc) {
 350                 dev_err(dev, "failed to alloc i2c mux\n");
 351                 ret = -ENOMEM;
 352                 goto err_mux_alloc;
 353         }
 354         data->muxc->priv = data;
 355
 356         /* register muxed i2c channels. One for each supported battery */
 357         for (i = 0; i < SBSM_MAX_BATS; ++i) {
 358                 if (data->supported_bats & BIT(i)) {
 359                         ret = i2c_mux_add_adapter(data->muxc, 0, i + 1, 0);
 360                         if (ret)
 361                                 break;
 362                 }
 363         }
 364         if (ret) {
 365                 dev_err(dev, "failed to register i2c mux channel %d\n", i + 1);
 366                 goto err_mux_register;
 367         }
 368
 369         psy_desc = devm_kmemdup(dev, &sbsm_default_psy_desc,
 370                                 sizeof(struct power_supply_desc),
 371                                 GFP_KERNEL);
 372         if (!psy_desc) {
 373                 ret = -ENOMEM;
 374                 goto err_psy;
 375         }
 376
 377         psy_desc->name = devm_kasprintf(dev, GFP_KERNEL, "sbsm-%s",
 378                                         dev_name(&client->dev));
 379         if (!psy_desc->name) {
 380                 ret = -ENOMEM;
 381                 goto err_psy;
 382         }
 383         ret = sbsm_gpio_setup(data);
 384         if (ret < 0)
 385                 goto err_psy;
 386
 387         psy_cfg.drv_data = data;
 388         psy_cfg.of_node = dev->of_node;
 389         data->psy = devm_power_supply_register(dev, psy_desc, &psy_cfg);
 390         if (IS_ERR(data->psy)) {
 391                 ret = PTR_ERR(data->psy);
 392                 dev_err(dev, "failed to register power supply %s\n",
 393                         psy_desc->name);
 394                 goto err_psy;
 395         }
 396
 397         return 0;
 398
 399 err_psy:
 400 err_mux_register:
 401         i2c_mux_del_adapters(data->muxc);
 402
 403 err_mux_alloc:
 404         return ret;
 405 }
 406
 407 static int sbsm_remove(struct i2c_client *client)
 408 {
 409         struct sbsm_data *data = i2c_get_clientdata(client);
 410
 411         i2c_mux_del_adapters(data->muxc);
 412         return 0;
 413 }
 414
 415 static const struct i2c_device_id sbsm_ids[] = {
 416         { "sbs-manager", 0 },
 417         { "ltc1760",     0 },
 418         { }
 419 };
 420 MODULE_DEVICE_TABLE(i2c, sbsm_ids);
 421
 422 #ifdef CONFIG_OF
 423 static const struct of_device_id sbsm_dt_ids[] = {
 424         { .compatible = "sbs,sbs-manager" },
 425         { .compatible = "lltc,ltc1760" },
 426         { }
 427 };
 428 MODULE_DEVICE_TABLE(of, sbsm_dt_ids);
 429 #endif
 430
 431 static struct i2c_driver sbsm_driver = {
 432         .driver = {
 433                 .name = "sbsm",
 434                 .of_match_table = of_match_ptr(sbsm_dt_ids),
 435         },
 436         .probe          = sbsm_probe,
 437         .remove         = sbsm_remove,
 438         .alert          = sbsm_alert,
 439         .id_table       = sbsm_ids
 440 };
 441 module_i2c_driver(sbsm_driver);
 442
 443 MODULE_LICENSE("GPL");
 444 MODULE_AUTHOR("Karl-Heinz Schneider <karl-heinz@schneider-inet.de>");
 445 MODULE_DESCRIPTION("SBSM Smart Battery System Manager");