drivers/regulator/max8649.c

   1 /*
   2  * Regulators driver for Maxim max8649
   3  *
   4  * Copyright (C) 2009-2010 Marvell International Ltd.
   5  *      Haojian Zhuang <haojian.zhuang@marvell.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11 #include <linux/kernel.h>
  12 #include <linux/module.h>
  13 #include <linux/err.h>
  14 #include <linux/i2c.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/regulator/driver.h>
  17 #include <linux/slab.h>
  18 #include <linux/regulator/max8649.h>
  19
  20 #define MAX8649_DCDC_VMIN       750000          /* uV */
  21 #define MAX8649_DCDC_VMAX       1380000         /* uV */
  22 #define MAX8649_DCDC_STEP       10000           /* uV */
  23 #define MAX8649_VOL_MASK        0x3f
  24
  25 /* Registers */
  26 #define MAX8649_MODE0           0x00
  27 #define MAX8649_MODE1           0x01
  28 #define MAX8649_MODE2           0x02
  29 #define MAX8649_MODE3           0x03
  30 #define MAX8649_CONTROL         0x04
  31 #define MAX8649_SYNC            0x05
  32 #define MAX8649_RAMP            0x06
  33 #define MAX8649_CHIP_ID1        0x08
  34 #define MAX8649_CHIP_ID2        0x09
  35
  36 /* Bits */
  37 #define MAX8649_EN_PD           (1 << 7)
  38 #define MAX8649_VID0_PD         (1 << 6)
  39 #define MAX8649_VID1_PD         (1 << 5)
  40 #define MAX8649_VID_MASK        (3 << 5)
  41
  42 #define MAX8649_FORCE_PWM       (1 << 7)
  43 #define MAX8649_SYNC_EXTCLK     (1 << 6)
  44
  45 #define MAX8649_EXT_MASK        (3 << 6)
  46
  47 #define MAX8649_RAMP_MASK       (7 << 5)
  48 #define MAX8649_RAMP_DOWN       (1 << 1)
  49
  50 struct max8649_regulator_info {
  51         struct regulator_dev    *regulator;
  52         struct i2c_client       *i2c;
  53         struct device           *dev;
  54         struct mutex            io_lock;
  55
  56         int             vol_reg;
  57         unsigned        mode:2; /* bit[1:0] = VID1, VID0 */
  58         unsigned        extclk_freq:2;
  59         unsigned        extclk:1;
  60         unsigned        ramp_timing:3;
  61         unsigned        ramp_down:1;
  62 };
  63
  64 /* I2C operations */
  65
  66 static inline int max8649_read_device(struct i2c_client *i2c,
  67                                       int reg, int bytes, void *dest)
  68 {
  69         unsigned char data;
  70         int ret;
  71
  72         data = (unsigned char)reg;
  73         ret = i2c_master_send(i2c, &data, 1);
  74         if (ret < 0)
  75                 return ret;
  76         ret = i2c_master_recv(i2c, dest, bytes);
  77         if (ret < 0)
  78                 return ret;
  79         return 0;
  80 }
  81
  82 static inline int max8649_write_device(struct i2c_client *i2c,
  83                                        int reg, int bytes, void *src)
  84 {
  85         unsigned char buf[bytes + 1];
  86         int ret;
  87
  88         buf[0] = (unsigned char)reg;
  89         memcpy(&buf[1], src, bytes);
  90
  91         ret = i2c_master_send(i2c, buf, bytes + 1);
  92         if (ret < 0)
  93                 return ret;
  94         return 0;
  95 }
  96
  97 static int max8649_reg_read(struct i2c_client *i2c, int reg)
  98 {
  99         struct max8649_regulator_info *info = i2c_get_clientdata(i2c);
 100         unsigned char data;
 101         int ret;
 102
 103         mutex_lock(&info->io_lock);
 104         ret = max8649_read_device(i2c, reg, 1, &data);
 105         mutex_unlock(&info->io_lock);
 106
 107         if (ret < 0)
 108                 return ret;
 109         return (int)data;
 110 }
 111
 112 static int max8649_set_bits(struct i2c_client *i2c, int reg,
 113                             unsigned char mask, unsigned char data)
 114 {
 115         struct max8649_regulator_info *info = i2c_get_clientdata(i2c);
 116         unsigned char value;
 117         int ret;
 118
 119         mutex_lock(&info->io_lock);
 120         ret = max8649_read_device(i2c, reg, 1, &value);
 121         if (ret < 0)
 122                 goto out;
 123         value &= ~mask;
 124         value |= data;
 125         ret = max8649_write_device(i2c, reg, 1, &value);
 126 out:
 127         mutex_unlock(&info->io_lock);
 128         return ret;
 129 }
 130
 131 static inline int check_range(int min_uV, int max_uV)
 132 {
 133         if ((min_uV < MAX8649_DCDC_VMIN) || (max_uV > MAX8649_DCDC_VMAX)
 134                 || (min_uV > max_uV))
 135                 return -EINVAL;
 136         return 0;
 137 }
 138
 139 static int max8649_list_voltage(struct regulator_dev *rdev, unsigned index)
 140 {
 141         return (MAX8649_DCDC_VMIN + index * MAX8649_DCDC_STEP);
 142 }
 143
 144 static int max8649_get_voltage(struct regulator_dev *rdev)
 145 {
 146         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
 147         unsigned char data;
 148         int ret;
 149
 150         ret = max8649_reg_read(info->i2c, info->vol_reg);
 151         if (ret < 0)
 152                 return ret;
 153         data = (unsigned char)ret & MAX8649_VOL_MASK;
 154         return max8649_list_voltage(rdev, data);
 155 }
 156
 157 static int max8649_set_voltage(struct regulator_dev *rdev,
 158                                int min_uV, int max_uV)
 159 {
 160         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
 161         unsigned char data, mask;
 162
 163         if (check_range(min_uV, max_uV)) {
 164                 dev_err(info->dev, "invalid voltage range (%d, %d) uV\n",
 165                         min_uV, max_uV);
 166                 return -EINVAL;
 167         }
 168         data = (min_uV - MAX8649_DCDC_VMIN + MAX8649_DCDC_STEP - 1)
 169                 / MAX8649_DCDC_STEP;
 170         mask = MAX8649_VOL_MASK;
 171
 172         return max8649_set_bits(info->i2c, info->vol_reg, mask, data);
 173 }
 174
 175 /* EN_PD means pulldown on EN input */
 176 static int max8649_enable(struct regulator_dev *rdev)
 177 {
 178         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
 179         return max8649_set_bits(info->i2c, MAX8649_CONTROL, MAX8649_EN_PD, 0);
 180 }
 181
 182 /*
 183  * Applied internal pulldown resistor on EN input pin.
 184  * If pulldown EN pin outside, it would be better.
 185  */
 186 static int max8649_disable(struct regulator_dev *rdev)
 187 {
 188         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
 189         return max8649_set_bits(info->i2c, MAX8649_CONTROL, MAX8649_EN_PD,
 190                                 MAX8649_EN_PD);
 191 }
 192
 193 static int max8649_is_enabled(struct regulator_dev *rdev)
 194 {
 195         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
 196         int ret;
 197
 198         ret = max8649_reg_read(info->i2c, MAX8649_CONTROL);
 199         if (ret < 0)
 200                 return ret;
 201         return !((unsigned char)ret & MAX8649_EN_PD);
 202 }
 203
 204 static int max8649_enable_time(struct regulator_dev *rdev)
 205 {
 206         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
 207         int voltage, rate, ret;
 208
 209         /* get voltage */
 210         ret = max8649_reg_read(info->i2c, info->vol_reg);
 211         if (ret < 0)
 212                 return ret;
 213         ret &= MAX8649_VOL_MASK;
 214         voltage = max8649_list_voltage(rdev, (unsigned char)ret); /* uV */
 215
 216         /* get rate */
 217         ret = max8649_reg_read(info->i2c, MAX8649_RAMP);
 218         if (ret < 0)
 219                 return ret;
 220         ret = (ret & MAX8649_RAMP_MASK) >> 5;
 221         rate = (32 * 1000) >> ret;      /* uV/uS */
 222
 223         return (voltage / rate);
 224 }
 225
 226 static int max8649_set_mode(struct regulator_dev *rdev, unsigned int mode)
 227 {
 228         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
 229
 230         switch (mode) {
 231         case REGULATOR_MODE_FAST:
 232                 max8649_set_bits(info->i2c, info->vol_reg, MAX8649_FORCE_PWM,
 233                                  MAX8649_FORCE_PWM);
 234                 break;
 235         case REGULATOR_MODE_NORMAL:
 236                 max8649_set_bits(info->i2c, info->vol_reg,
 237                                  MAX8649_FORCE_PWM, 0);
 238                 break;
 239         default:
 240                 return -EINVAL;
 241         }
 242         return 0;
 243 }
 244
 245 static unsigned int max8649_get_mode(struct regulator_dev *rdev)
 246 {
 247         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
 248         int ret;
 249
 250         ret = max8649_reg_read(info->i2c, info->vol_reg);
 251         if (ret & MAX8649_FORCE_PWM)
 252                 return REGULATOR_MODE_FAST;
 253         return REGULATOR_MODE_NORMAL;
 254 }
 255
 256 static struct regulator_ops max8649_dcdc_ops = {
 257         .set_voltage    = max8649_set_voltage,
 258         .get_voltage    = max8649_get_voltage,
 259         .list_voltage   = max8649_list_voltage,
 260         .enable         = max8649_enable,
 261         .disable        = max8649_disable,
 262         .is_enabled     = max8649_is_enabled,
 263         .enable_time    = max8649_enable_time,
 264         .set_mode       = max8649_set_mode,
 265         .get_mode       = max8649_get_mode,
 266
 267 };
 268
 269 static struct regulator_desc dcdc_desc = {
 270         .name           = "max8649",
 271         .ops            = &max8649_dcdc_ops,
 272         .type           = REGULATOR_VOLTAGE,
 273         .n_voltages     = 1 << 6,
 274         .owner          = THIS_MODULE,
 275 };
 276
 277 static int __devinit max8649_regulator_probe(struct i2c_client *client,
 278                                              const struct i2c_device_id *id)
 279 {
 280         struct max8649_platform_data *pdata = client->dev.platform_data;
 281         struct max8649_regulator_info *info = NULL;
 282         unsigned char data;
 283         int ret;
 284
 285         info = kzalloc(sizeof(struct max8649_regulator_info), GFP_KERNEL);
 286         if (!info) {
 287                 dev_err(&client->dev, "No enough memory\n");
 288                 return -ENOMEM;
 289         }
 290
 291         info->i2c = client;
 292         info->dev = &client->dev;
 293         mutex_init(&info->io_lock);
 294         i2c_set_clientdata(client, info);
 295
 296         info->mode = pdata->mode;
 297         switch (info->mode) {
 298         case 0:
 299                 info->vol_reg = MAX8649_MODE0;
 300                 break;
 301         case 1:
 302                 info->vol_reg = MAX8649_MODE1;
 303                 break;
 304         case 2:
 305                 info->vol_reg = MAX8649_MODE2;
 306                 break;
 307         case 3:
 308                 info->vol_reg = MAX8649_MODE3;
 309                 break;
 310         default:
 311                 break;
 312         }
 313
 314         ret = max8649_reg_read(info->i2c, MAX8649_CHIP_ID1);
 315         if (ret < 0) {
 316                 dev_err(info->dev, "Failed to detect ID of MAX8649:%d\n",
 317                         ret);
 318                 goto out;
 319         }
 320         dev_info(info->dev, "Detected MAX8649 (ID:%x)\n", ret);
 321
 322         /* enable VID0 & VID1 */
 323         max8649_set_bits(info->i2c, MAX8649_CONTROL, MAX8649_VID_MASK, 0);
 324
 325         /* enable/disable external clock synchronization */
 326         info->extclk = pdata->extclk;
 327         data = (info->extclk) ? MAX8649_SYNC_EXTCLK : 0;
 328         max8649_set_bits(info->i2c, info->vol_reg, MAX8649_SYNC_EXTCLK, data);
 329         if (info->extclk) {
 330                 /* set external clock frequency */
 331                 info->extclk_freq = pdata->extclk_freq;
 332                 max8649_set_bits(info->i2c, MAX8649_SYNC, MAX8649_EXT_MASK,
 333                                  info->extclk_freq << 6);
 334         }
 335
 336         if (pdata->ramp_timing) {
 337                 info->ramp_timing = pdata->ramp_timing;
 338                 max8649_set_bits(info->i2c, MAX8649_RAMP, MAX8649_RAMP_MASK,
 339                                  info->ramp_timing << 5);
 340         }
 341
 342         info->ramp_down = pdata->ramp_down;
 343         if (info->ramp_down) {
 344                 max8649_set_bits(info->i2c, MAX8649_RAMP, MAX8649_RAMP_DOWN,
 345                                  MAX8649_RAMP_DOWN);
 346         }
 347
 348         info->regulator = regulator_register(&dcdc_desc, &client->dev,
 349                                              pdata->regulator, info);
 350         if (IS_ERR(info->regulator)) {
 351                 dev_err(info->dev, "failed to register regulator %s\n",
 352                         dcdc_desc.name);
 353                 ret = PTR_ERR(info->regulator);
 354                 goto out;
 355         }
 356
 357         dev_info(info->dev, "Max8649 regulator device is detected.\n");
 358         return 0;
 359 out:
 360         kfree(info);
 361         return ret;
 362 }
 363
 364 static int __devexit max8649_regulator_remove(struct i2c_client *client)
 365 {
 366         struct max8649_regulator_info *info = i2c_get_clientdata(client);
 367
 368         if (info) {
 369                 if (info->regulator)
 370                         regulator_unregister(info->regulator);
 371                 kfree(info);
 372         }
 373
 374         return 0;
 375 }
 376
 377 static const struct i2c_device_id max8649_id[] = {
 378         { "max8649", 0 },
 379         { }
 380 };
 381 MODULE_DEVICE_TABLE(i2c, max8649_id);
 382
 383 static struct i2c_driver max8649_driver = {
 384         .probe          = max8649_regulator_probe,
 385         .remove         = __devexit_p(max8649_regulator_remove),
 386         .driver         = {
 387                 .name   = "max8649",
 388         },
 389         .id_table       = max8649_id,
 390 };
 391
 392 static int __init max8649_init(void)
 393 {
 394         return i2c_add_driver(&max8649_driver);
 395 }
 396 subsys_initcall(max8649_init);
 397
 398 static void __exit max8649_exit(void)
 399 {
 400         i2c_del_driver(&max8649_driver);
 401 }
 402 module_exit(max8649_exit);
 403
 404 /* Module information */
 405 MODULE_DESCRIPTION("MAXIM 8649 voltage regulator driver");
 406 MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
 407 MODULE_LICENSE("GPL");
 408