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