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, unsigned *selector) 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 *selector = data & mask; 172 173 return max8649_set_bits(info->i2c, info->vol_reg, mask, data); 174 } 175 176 /* EN_PD means pulldown on EN input */ 177 static int max8649_enable(struct regulator_dev *rdev) 178 { 179 struct max8649_regulator_info *info = rdev_get_drvdata(rdev); 180 return max8649_set_bits(info->i2c, MAX8649_CONTROL, MAX8649_EN_PD, 0); 181 } 182 183 /* 184 * Applied internal pulldown resistor on EN input pin. 185 * If pulldown EN pin outside, it would be better. 186 */ 187 static int max8649_disable(struct regulator_dev *rdev) 188 { 189 struct max8649_regulator_info *info = rdev_get_drvdata(rdev); 190 return max8649_set_bits(info->i2c, MAX8649_CONTROL, MAX8649_EN_PD, 191 MAX8649_EN_PD); 192 } 193 194 static int max8649_is_enabled(struct regulator_dev *rdev) 195 { 196 struct max8649_regulator_info *info = rdev_get_drvdata(rdev); 197 int ret; 198 199 ret = max8649_reg_read(info->i2c, MAX8649_CONTROL); 200 if (ret < 0) 201 return ret; 202 return !((unsigned char)ret & MAX8649_EN_PD); 203 } 204 205 static int max8649_enable_time(struct regulator_dev *rdev) 206 { 207 struct max8649_regulator_info *info = rdev_get_drvdata(rdev); 208 int voltage, rate, ret; 209 210 /* get voltage */ 211 ret = max8649_reg_read(info->i2c, info->vol_reg); 212 if (ret < 0) 213 return ret; 214 ret &= MAX8649_VOL_MASK; 215 voltage = max8649_list_voltage(rdev, (unsigned char)ret); /* uV */ 216 217 /* get rate */ 218 ret = max8649_reg_read(info->i2c, MAX8649_RAMP); 219 if (ret < 0) 220 return ret; 221 ret = (ret & MAX8649_RAMP_MASK) >> 5; 222 rate = (32 * 1000) >> ret; /* uV/uS */ 223 224 return DIV_ROUND_UP(voltage, rate); 225 } 226 227 static int max8649_set_mode(struct regulator_dev *rdev, unsigned int mode) 228 { 229 struct max8649_regulator_info *info = rdev_get_drvdata(rdev); 230 231 switch (mode) { 232 case REGULATOR_MODE_FAST: 233 max8649_set_bits(info->i2c, info->vol_reg, MAX8649_FORCE_PWM, 234 MAX8649_FORCE_PWM); 235 break; 236 case REGULATOR_MODE_NORMAL: 237 max8649_set_bits(info->i2c, info->vol_reg, 238 MAX8649_FORCE_PWM, 0); 239 break; 240 default: 241 return -EINVAL; 242 } 243 return 0; 244 } 245 246 static unsigned int max8649_get_mode(struct regulator_dev *rdev) 247 { 248 struct max8649_regulator_info *info = rdev_get_drvdata(rdev); 249 int ret; 250 251 ret = max8649_reg_read(info->i2c, info->vol_reg); 252 if (ret & MAX8649_FORCE_PWM) 253 return REGULATOR_MODE_FAST; 254 return REGULATOR_MODE_NORMAL; 255 } 256 257 static struct regulator_ops max8649_dcdc_ops = { 258 .set_voltage = max8649_set_voltage, 259 .get_voltage = max8649_get_voltage, 260 .list_voltage = max8649_list_voltage, 261 .enable = max8649_enable, 262 .disable = max8649_disable, 263 .is_enabled = max8649_is_enabled, 264 .enable_time = max8649_enable_time, 265 .set_mode = max8649_set_mode, 266 .get_mode = max8649_get_mode, 267 268 }; 269 270 static struct regulator_desc dcdc_desc = { 271 .name = "max8649", 272 .ops = &max8649_dcdc_ops, 273 .type = REGULATOR_VOLTAGE, 274 .n_voltages = 1 << 6, 275 .owner = THIS_MODULE, 276 }; 277 278 static int __devinit max8649_regulator_probe(struct i2c_client *client, 279 const struct i2c_device_id *id) 280 { 281 struct max8649_platform_data *pdata = client->dev.platform_data; 282 struct max8649_regulator_info *info = NULL; 283 unsigned char data; 284 int ret; 285 286 info = kzalloc(sizeof(struct max8649_regulator_info), GFP_KERNEL); 287 if (!info) { 288 dev_err(&client->dev, "No enough memory\n"); 289 return -ENOMEM; 290 } 291 292 info->i2c = client; 293 info->dev = &client->dev; 294 mutex_init(&info->io_lock); 295 i2c_set_clientdata(client, info); 296 297 info->mode = pdata->mode; 298 switch (info->mode) { 299 case 0: 300 info->vol_reg = MAX8649_MODE0; 301 break; 302 case 1: 303 info->vol_reg = MAX8649_MODE1; 304 break; 305 case 2: 306 info->vol_reg = MAX8649_MODE2; 307 break; 308 case 3: 309 info->vol_reg = MAX8649_MODE3; 310 break; 311 default: 312 break; 313 } 314 315 ret = max8649_reg_read(info->i2c, MAX8649_CHIP_ID1); 316 if (ret < 0) { 317 dev_err(info->dev, "Failed to detect ID of MAX8649:%d\n", 318 ret); 319 goto out; 320 } 321 dev_info(info->dev, "Detected MAX8649 (ID:%x)\n", ret); 322 323 /* enable VID0 & VID1 */ 324 max8649_set_bits(info->i2c, MAX8649_CONTROL, MAX8649_VID_MASK, 0); 325 326 /* enable/disable external clock synchronization */ 327 info->extclk = pdata->extclk; 328 data = (info->extclk) ? MAX8649_SYNC_EXTCLK : 0; 329 max8649_set_bits(info->i2c, info->vol_reg, MAX8649_SYNC_EXTCLK, data); 330 if (info->extclk) { 331 /* set external clock frequency */ 332 info->extclk_freq = pdata->extclk_freq; 333 max8649_set_bits(info->i2c, MAX8649_SYNC, MAX8649_EXT_MASK, 334 info->extclk_freq << 6); 335 } 336 337 if (pdata->ramp_timing) { 338 info->ramp_timing = pdata->ramp_timing; 339 max8649_set_bits(info->i2c, MAX8649_RAMP, MAX8649_RAMP_MASK, 340 info->ramp_timing << 5); 341 } 342 343 info->ramp_down = pdata->ramp_down; 344 if (info->ramp_down) { 345 max8649_set_bits(info->i2c, MAX8649_RAMP, MAX8649_RAMP_DOWN, 346 MAX8649_RAMP_DOWN); 347 } 348 349 info->regulator = regulator_register(&dcdc_desc, &client->dev, 350 pdata->regulator, info, NULL); 351 if (IS_ERR(info->regulator)) { 352 dev_err(info->dev, "failed to register regulator %s\n", 353 dcdc_desc.name); 354 ret = PTR_ERR(info->regulator); 355 goto out; 356 } 357 358 dev_info(info->dev, "Max8649 regulator device is detected.\n"); 359 return 0; 360 out: 361 kfree(info); 362 return ret; 363 } 364 365 static int __devexit max8649_regulator_remove(struct i2c_client *client) 366 { 367 struct max8649_regulator_info *info = i2c_get_clientdata(client); 368 369 if (info) { 370 if (info->regulator) 371 regulator_unregister(info->regulator); 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 410