drivers/mfd/tps65910.c

   1 /*
   2  * tps65910.c  --  TI TPS6591x
   3  *
   4  * Copyright 2010 Texas Instruments Inc.
   5  *
   6  * Author: Graeme Gregory <gg@slimlogic.co.uk>
   7  * Author: Jorge Eduardo Candelaria <jedu@slimlogic.co.uk>
   8  *
   9  *  This program is free software; you can redistribute it and/or modify it
  10  *  under  the terms of the GNU General  Public License as published by the
  11  *  Free Software Foundation;  either version 2 of the License, or (at your
  12  *  option) any later version.
  13  *
  14  */
  15
  16 #include <linux/module.h>
  17 #include <linux/moduleparam.h>
  18 #include <linux/init.h>
  19 #include <linux/slab.h>
  20 #include <linux/i2c.h>
  21 #include <linux/gpio.h>
  22 #include <linux/mfd/core.h>
  23 #include <linux/mfd/tps65910.h>
  24
  25 struct tps65910 *g_tps65910;
  26
  27 static struct mfd_cell tps65910s[] = {
  28         {
  29                 .name = "tps65910-pmic",
  30         },
  31         {
  32                 .name = "tps65910-rtc",
  33         },
  34         {
  35                 .name = "tps65910-power",
  36         },
  37 };
  38
  39 #define TPS65910_SPEED  200 * 1000
  40
  41 static int tps65910_i2c_read(struct tps65910 *tps65910, u8 reg,
  42                                   int bytes, void *dest)
  43 {
  44         struct i2c_client *i2c = tps65910->i2c_client;
  45         struct i2c_msg xfer[2];
  46         int ret;
  47         //int i;
  48
  49         /* Write register */
  50         xfer[0].addr = i2c->addr;
  51         xfer[0].flags = 0;
  52         xfer[0].len = 1;
  53         xfer[0].buf = &reg;
  54         xfer[0].scl_rate = TPS65910_SPEED;
  55
  56         /* Read data */
  57         xfer[1].addr = i2c->addr;
  58         xfer[1].flags = I2C_M_RD;
  59         xfer[1].len = bytes;
  60         xfer[1].buf = dest;
  61         xfer[1].scl_rate = TPS65910_SPEED;
  62
  63         ret = i2c_transfer(i2c->adapter, xfer, 2);
  64         //for(i=0;i<bytes;i++)
  65         //printk("%s:reg=0x%x,value=0x%x\n",__func__,reg+i,*(u8 *)dest++);
  66         if (ret == 2)
  67                 ret = 0;
  68         else if (ret >= 0)
  69                 ret = -EIO;
  70
  71         return ret;
  72 }
  73
  74 static int tps65910_i2c_write(struct tps65910 *tps65910, u8 reg,
  75                                    int bytes, void *src)
  76 {
  77         struct i2c_client *i2c = tps65910->i2c_client;
  78         /* we add 1 byte for device register */
  79         u8 msg[TPS65910_MAX_REGISTER + 1];
  80         int ret;
  81         //int i;
  82
  83         if (bytes > TPS65910_MAX_REGISTER)
  84                 return -EINVAL;
  85
  86         msg[0] = reg;
  87         memcpy(&msg[1], src, bytes);
  88
  89         //for(i=0;i<bytes;i++)
  90         //printk("%s:reg=0x%x,value=0x%x\n",__func__,reg+i,msg[i+1]);
  91
  92         ret = i2c_master_send(i2c, msg, bytes + 1);
  93         if (ret < 0)
  94                 return ret;
  95         if (ret != bytes + 1)
  96                 return -EIO;
  97
  98         return 0;
  99 }
 100
 101 static inline int tps65910_read(struct tps65910 *tps65910, u8 reg)
 102 {
 103         u8 val;
 104         int err;
 105
 106         err = tps65910->read(tps65910, reg, 1, &val);
 107         if (err < 0)
 108                 return err;
 109
 110         return val;
 111 }
 112
 113 static inline int tps65910_write(struct tps65910 *tps65910, u8 reg, u8 val)
 114 {
 115         return tps65910->write(tps65910, reg, 1, &val);
 116 }
 117
 118 int tps65910_reg_read(struct tps65910 *tps65910, u8 reg)
 119 {
 120         int data;
 121
 122         mutex_lock(&tps65910->io_mutex);
 123
 124         data = tps65910_read(tps65910, reg);
 125         if (data < 0)
 126                 dev_err(tps65910->dev, "Read from reg 0x%x failed\n", reg);
 127
 128         mutex_unlock(&tps65910->io_mutex);
 129         return data;
 130 }
 131 EXPORT_SYMBOL_GPL(tps65910_reg_read);
 132
 133 int tps65910_reg_write(struct tps65910 *tps65910, u8 reg, u8 val)
 134 {
 135         int err;
 136
 137         mutex_lock(&tps65910->io_mutex);
 138
 139         err = tps65910_write(tps65910, reg, val);
 140         if (err < 0)
 141                 dev_err(tps65910->dev, "Write for reg 0x%x failed\n", reg);
 142
 143         mutex_unlock(&tps65910->io_mutex);
 144         return err;
 145 }
 146 EXPORT_SYMBOL_GPL(tps65910_reg_write);
 147
 148 /**
 149  * tps65910_bulk_read: Read multiple tps65910 registers
 150  *
 151  * @tps65910: Device to read from
 152  * @reg: First register
 153  * @count: Number of registers
 154  * @buf: Buffer to fill.
 155  */
 156 int tps65910_bulk_read(struct tps65910 *tps65910, u8 reg,
 157                      int count, u8 *buf)
 158 {
 159         int ret;
 160
 161         mutex_lock(&tps65910->io_mutex);
 162
 163         ret = tps65910->read(tps65910, reg, count, buf);
 164
 165         mutex_unlock(&tps65910->io_mutex);
 166
 167         return ret;
 168 }
 169 EXPORT_SYMBOL_GPL(tps65910_bulk_read);
 170
 171 int tps65910_bulk_write(struct tps65910 *tps65910, u8 reg,
 172                      int count, u8 *buf)
 173 {
 174         int ret;
 175
 176         mutex_lock(&tps65910->io_mutex);
 177
 178         ret = tps65910->write(tps65910, reg, count, buf);
 179
 180         mutex_unlock(&tps65910->io_mutex);
 181
 182         return ret;
 183 }
 184 EXPORT_SYMBOL_GPL(tps65910_bulk_write);
 185
 186
 187
 188
 189 int tps65910_set_bits(struct tps65910 *tps65910, u8 reg, u8 mask)
 190 {
 191         u8 data;
 192         int err;
 193
 194         mutex_lock(&tps65910->io_mutex);
 195         err = tps65910_i2c_read(tps65910, reg, 1, &data);
 196         if (err) {
 197                 dev_err(tps65910->dev, "%s:read from reg %x failed\n", __func__,reg);
 198                 goto out;
 199         }
 200
 201         data |= mask;
 202         err = tps65910_i2c_write(tps65910, reg, 1, &data);
 203         if (err)
 204                 dev_err(tps65910->dev, "%s:write to reg %x failed\n", __func__,reg);
 205
 206 out:
 207         mutex_unlock(&tps65910->io_mutex);
 208         return err;
 209 }
 210 EXPORT_SYMBOL_GPL(tps65910_set_bits);
 211
 212 int tps65910_clear_bits(struct tps65910 *tps65910, u8 reg, u8 mask)
 213 {
 214         u8 data;
 215         int err;
 216
 217         mutex_lock(&tps65910->io_mutex);
 218         err = tps65910_i2c_read(tps65910, reg, 1, &data);
 219         if (err) {
 220                 dev_err(tps65910->dev, "read from reg %x failed\n", reg);
 221                 goto out;
 222         }
 223
 224         data &= ~mask;
 225         err = tps65910_i2c_write(tps65910, reg, 1, &data);
 226         if (err)
 227                 dev_err(tps65910->dev, "write to reg %x failed\n", reg);
 228
 229 out:
 230         mutex_unlock(&tps65910->io_mutex);
 231         return err;
 232 }
 233 EXPORT_SYMBOL_GPL(tps65910_clear_bits);
 234
 235 static int tps65910_i2c_probe(struct i2c_client *i2c,
 236                             const struct i2c_device_id *id)
 237 {
 238         struct tps65910 *tps65910;
 239         struct tps65910_board *pmic_plat_data;
 240         struct tps65910_platform_data *init_data;
 241         int ret = 0;
 242
 243         pmic_plat_data = dev_get_platdata(&i2c->dev);
 244         if (!pmic_plat_data)
 245                 return -EINVAL;
 246
 247         init_data = kzalloc(sizeof(struct tps65910_platform_data), GFP_KERNEL);
 248         if (init_data == NULL)
 249                 return -ENOMEM;
 250
 251         init_data->irq = pmic_plat_data->irq;
 252         init_data->irq_base = pmic_plat_data->irq_base;
 253
 254         tps65910 = kzalloc(sizeof(struct tps65910), GFP_KERNEL);
 255         if (tps65910 == NULL)
 256                 return -ENOMEM;
 257
 258         i2c_set_clientdata(i2c, tps65910);
 259         tps65910->dev = &i2c->dev;
 260         tps65910->i2c_client = i2c;
 261         tps65910->id = id->driver_data;
 262         tps65910->read = tps65910_i2c_read;
 263         tps65910->write = tps65910_i2c_write;
 264         mutex_init(&tps65910->io_mutex);
 265
 266         ret = mfd_add_devices(tps65910->dev, -1,
 267                               tps65910s, ARRAY_SIZE(tps65910s),
 268                               NULL, 0);
 269         if (ret < 0)
 270                 goto err;
 271
 272         g_tps65910 = tps65910;
 273
 274         if (pmic_plat_data && pmic_plat_data->pre_init) {
 275                 ret = pmic_plat_data->pre_init(tps65910);
 276                 if (ret != 0) {
 277                         dev_err(tps65910->dev, "pre_init() failed: %d\n", ret);
 278                         goto err;
 279                 }
 280         }
 281
 282         tps65910_gpio_init(tps65910, pmic_plat_data->gpio_base);
 283
 284         ret = tps65910_irq_init(tps65910, init_data->irq, init_data);
 285         if (ret < 0)
 286                 goto err;
 287
 288         if (pmic_plat_data && pmic_plat_data->post_init) {
 289                 ret = pmic_plat_data->post_init(tps65910);
 290                 if (ret != 0) {
 291                         dev_err(tps65910->dev, "post_init() failed: %d\n", ret);
 292                         goto err;
 293                 }
 294         }
 295
 296         printk("%s:irq=%d,irq_base=%d,gpio_base=%d\n",__func__,init_data->irq,init_data->irq_base,pmic_plat_data->gpio_base);
 297         return ret;
 298
 299 err:
 300         mfd_remove_devices(tps65910->dev);
 301         kfree(tps65910);
 302         return ret;
 303 }
 304
 305
 306 int tps65910_device_shutdown(void)
 307 {
 308         int val = 0;
 309         int err = -1;
 310         struct tps65910 *tps65910 = g_tps65910;
 311
 312         printk("%s\n",__func__);
 313
 314         val = tps65910_reg_read(tps65910, TPS65910_DEVCTRL);
 315         if (val<0) {
 316                 printk(KERN_ERR "Unable to read TPS65910_REG_DCDCCTRL reg\n");
 317                 return -EIO;
 318         }
 319
 320         val |= DEVCTRL_DEV_OFF_MASK;
 321         val &= ~DEVCTRL_CK32K_CTRL_MASK;        //keep rtc
 322         err = tps65910_reg_write(tps65910, TPS65910_DEVCTRL, val);
 323         if (err) {
 324                 printk(KERN_ERR "Unable to read TPS65910 Reg at offset 0x%x= \
 325                                 \n", TPS65910_REG_VDIG1);
 326                 return err;
 327         }
 328
 329         return 0;
 330 }
 331 EXPORT_SYMBOL_GPL(tps65910_device_shutdown);
 332
 333
 334
 335 static int tps65910_i2c_remove(struct i2c_client *i2c)
 336 {
 337         struct tps65910 *tps65910 = i2c_get_clientdata(i2c);
 338
 339         mfd_remove_devices(tps65910->dev);
 340         kfree(tps65910);
 341
 342         return 0;
 343 }
 344
 345 static const struct i2c_device_id tps65910_i2c_id[] = {
 346        { "tps65910", TPS65910 },
 347        { "tps65911", TPS65911 },
 348        { }
 349 };
 350 MODULE_DEVICE_TABLE(i2c, tps65910_i2c_id);
 351
 352
 353 static struct i2c_driver tps65910_i2c_driver = {
 354         .driver = {
 355                    .name = "tps65910",
 356                    .owner = THIS_MODULE,
 357         },
 358         .probe = tps65910_i2c_probe,
 359         .remove = tps65910_i2c_remove,
 360         .id_table = tps65910_i2c_id,
 361 };
 362
 363 static int __init tps65910_i2c_init(void)
 364 {
 365         return i2c_add_driver(&tps65910_i2c_driver);
 366 }
 367 /* init early so consumer devices can complete system boot */
 368 subsys_initcall_sync(tps65910_i2c_init);
 369
 370 static void __exit tps65910_i2c_exit(void)
 371 {
 372         i2c_del_driver(&tps65910_i2c_driver);
 373 }
 374 module_exit(tps65910_i2c_exit);
 375
 376 MODULE_AUTHOR("Graeme Gregory <gg@slimlogic.co.uk>");
 377 MODULE_AUTHOR("Jorge Eduardo Candelaria <jedu@slimlogic.co.uk>");
 378 MODULE_DESCRIPTION("TPS6591x chip family multi-function driver");
 379 MODULE_LICENSE("GPL");