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 50struct 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 66static 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 82static 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 97static 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 112static 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); 126out: 127 mutex_unlock(&info->io_lock); 128 return ret; 129} 130 131static 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 139static int max8649_list_voltage(struct regulator_dev *rdev, unsigned index) 140{ 141 return (MAX8649_DCDC_VMIN + index * MAX8649_DCDC_STEP); 142} 143 144static 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 157static 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 */ 176static 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 */ 186static 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 193static 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 204static 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 226static 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 245static 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 256static 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 269static 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 277static 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; 359out: 360 kfree(info); 361 return ret; 362} 363 364static 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 377static const struct i2c_device_id max8649_id[] = { 378 { "max8649", 0 }, 379 { } 380}; 381MODULE_DEVICE_TABLE(i2c, max8649_id); 382 383static 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 392static int __init max8649_init(void) 393{ 394 return i2c_add_driver(&max8649_driver); 395} 396subsys_initcall(max8649_init); 397 398static void __exit max8649_exit(void) 399{ 400 i2c_del_driver(&max8649_driver); 401} 402module_exit(max8649_exit); 403 404/* Module information */ 405MODULE_DESCRIPTION("MAXIM 8649 voltage regulator driver"); 406MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>"); 407MODULE_LICENSE("GPL"); 408