drivers/mfd/rt5025-i2c.c

   1 /* drivers/mfd/rt5025-i2c.c
   2  * I2C Driver for Richtek RT5025
   3  * Multi function device - multi functional baseband PMIC
   4  *
   5  * Copyright (C) 2013
   6  * Author: CY Huang <cy_huang@richtek.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12
  13 #include <linux/module.h>
  14 #include <linux/kernel.h>
  15 #include <linux/i2c.h>
  16 #include <linux/slab.h>
  17 #include <linux/mfd/rt5025.h>
  18
  19 #define ROCKCHIP_I2C_RATE (200*1000)
  20
  21 static inline int rt5025_read_device(struct i2c_client *i2c,
  22                                       int reg, int bytes, void *dest)
  23 {
  24         #if 1
  25         int ret;
  26         unsigned char reg_addr = reg;
  27         struct i2c_msg i2c_msg[2];
  28         i2c_msg[0].addr = i2c->addr;
  29         i2c_msg[0].flags = i2c->flags;
  30         i2c_msg[0].len = 1;
  31         i2c_msg[0].buf = &reg_addr;
  32         i2c_msg[0].scl_rate = ROCKCHIP_I2C_RATE;
  33         i2c_msg[1].addr = i2c->addr;
  34         i2c_msg[1].flags = i2c->flags | I2C_M_RD;
  35         i2c_msg[1].len = bytes;
  36         i2c_msg[1].buf = dest;
  37         i2c_msg[1].scl_rate = ROCKCHIP_I2C_RATE;
  38         ret = i2c_transfer(i2c->adapter, i2c_msg, 2);
  39         #else
  40         int ret;
  41         if (bytes > 1)
  42                 ret = i2c_smbus_read_i2c_block_data(i2c, reg, bytes, dest);
  43         else {
  44                 ret = i2c_smbus_read_byte_data(i2c, reg);
  45                 if (ret < 0)
  46                         return ret;
  47                 *(unsigned char *)dest = (unsigned char)ret;
  48         }
  49         #endif
  50         return ret;
  51 }
  52
  53 int rt5025_reg_block_read(struct i2c_client *i2c, \
  54                         int reg, int bytes, void *dest)
  55 {
  56         return rt5025_read_device(i2c, reg, bytes, dest);
  57 }
  58 EXPORT_SYMBOL(rt5025_reg_block_read);
  59
  60 static inline int rt5025_write_device(struct i2c_client *i2c,
  61                                       int reg, int bytes, void *dest)
  62 {
  63         #if 1
  64         int ret;
  65         struct i2c_msg i2c_msg;
  66         char *tx_buf = (char*)kmalloc(bytes+1, GFP_KERNEL);
  67         tx_buf[0] = reg;
  68         memcpy(tx_buf+1, dest, bytes);
  69         i2c_msg.addr = i2c->addr;
  70         i2c_msg.flags = i2c->flags;
  71         i2c_msg.len = bytes + 1;
  72         i2c_msg.buf = tx_buf;
  73         i2c_msg.scl_rate = ROCKCHIP_I2C_RATE;
  74         ret = i2c_transfer(i2c->adapter, &i2c_msg, 1);
  75         kfree(tx_buf);
  76         #else
  77         int ret;
  78         if (bytes > 1)
  79                 ret = i2c_smbus_write_i2c_block_data(i2c, reg, bytes, dest);
  80         else {
  81                 ret = i2c_smbus_write_byte_data(i2c, reg, dest);
  82                 if (ret < 0)
  83                         return ret;
  84                 *(unsigned char *)dest = (unsigned char)ret;
  85         }
  86         #endif
  87         return ret;
  88 }
  89
  90 int rt5025_reg_block_write(struct i2c_client *i2c, \
  91                         int reg, int bytes, void *dest)
  92 {
  93         return rt5025_write_device(i2c, reg, bytes, dest);
  94 }
  95 EXPORT_SYMBOL(rt5025_reg_block_write);
  96
  97 int rt5025_reg_read(struct i2c_client *i2c, int reg)
  98 {
  99         struct rt5025_chip* chip = i2c_get_clientdata(i2c);
 100         int ret;
 101         #if 1
 102         unsigned char reg_addr = reg;
 103         unsigned char reg_data = 0;
 104         struct i2c_msg i2c_msg[2];
 105         RTINFO("I2C Read (client : 0x%x) reg = 0x%x\n",
 106            (unsigned int)i2c,(unsigned int)reg);
 107         mutex_lock(&chip->io_lock);
 108         i2c_msg[0].addr = i2c->addr;
 109         i2c_msg[0].flags = i2c->flags;
 110         i2c_msg[0].len = 1;
 111         i2c_msg[0].buf = &reg_addr;
 112         i2c_msg[0].scl_rate = ROCKCHIP_I2C_RATE;
 113         i2c_msg[1].addr = i2c->addr;
 114         i2c_msg[1].flags = i2c->flags | I2C_M_RD;
 115         i2c_msg[1].len = 1;
 116         i2c_msg[1].buf = &reg_data;
 117         i2c_msg[1].scl_rate = ROCKCHIP_I2C_RATE;
 118         ret = i2c_transfer(i2c->adapter, i2c_msg, 2);
 119         mutex_unlock(&chip->io_lock);
 120         #else
 121         RTINFO("I2C Read (client : 0x%x) reg = 0x%x\n",
 122            (unsigned int)i2c,(unsigned int)reg);
 123         mutex_lock(&chip->io_lock);
 124         ret = i2c_smbus_read_byte_data(i2c, reg);
 125         mutex_unlock(&chip->io_lock);
 126         #endif
 127         return reg_data;
 128 }
 129 EXPORT_SYMBOL(rt5025_reg_read);
 130
 131 int rt5025_reg_write(struct i2c_client *i2c, int reg, unsigned char data)
 132 {
 133         struct rt5025_chip* chip = i2c_get_clientdata(i2c);
 134         int ret;
 135         #if 1
 136         unsigned char xfer_data[2];
 137         struct i2c_msg i2c_msg;
 138         RTINFO("I2C Write (client : 0x%x) reg = 0x%x, data = 0x%x\n",
 139            (unsigned int)i2c,(unsigned int)reg,(unsigned int)data);
 140         xfer_data[0] = reg;
 141         xfer_data[1] = data;
 142         mutex_lock(&chip->io_lock);
 143         i2c_msg.addr = i2c->addr;
 144         i2c_msg.flags = i2c->flags;
 145         i2c_msg.len = 2;
 146         i2c_msg.buf = xfer_data;
 147         i2c_msg.scl_rate = ROCKCHIP_I2C_RATE;
 148         ret = i2c_transfer(i2c->adapter, &i2c_msg, 1);
 149         mutex_unlock(&chip->io_lock);
 150         #else
 151         RTINFO("I2C Write (client : 0x%x) reg = 0x%x, data = 0x%x\n",
 152            (unsigned int)i2c,(unsigned int)reg,(unsigned int)data);
 153         mutex_lock(&chip->io_lock);
 154         ret = i2c_smbus_write_byte_data(i2c, reg, data);
 155         mutex_unlock(&chip->io_lock);
 156         #endif
 157
 158         return ret;
 159 }
 160 EXPORT_SYMBOL(rt5025_reg_write);
 161
 162 int rt5025_assign_bits(struct i2c_client *i2c, int reg,
 163                 unsigned char mask, unsigned char data)
 164 {
 165         struct rt5025_chip *chip = i2c_get_clientdata(i2c);
 166         unsigned char value;
 167         int ret;
 168         #if 1
 169         struct i2c_msg i2c_msg;
 170         u8 xfer_data[2] = {0};
 171         mutex_lock(&chip->io_lock);
 172         ret = rt5025_read_device(i2c, reg, 1, &value);
 173         if (ret < 0)
 174                 goto out;
 175
 176         value &= ~mask;
 177         value |= (data&mask);
 178         xfer_data[0] = reg;
 179         xfer_data[1] = value;
 180         i2c_msg.addr = i2c->addr;
 181         i2c_msg.flags = i2c->flags;
 182         i2c_msg.len = 2;
 183         i2c_msg.buf = xfer_data;
 184         i2c_msg.scl_rate = ROCKCHIP_I2C_RATE;
 185         ret = i2c_transfer(i2c->adapter, &i2c_msg, 1);
 186         #else
 187         mutex_lock(&chip->io_lock);
 188
 189         ret = rt5025_read_device(i2c, reg, 1, &value);
 190
 191         if (ret < 0)
 192                 goto out;
 193         value &= ~mask;
 194         value |= (data&mask);
 195         ret = i2c_smbus_write_byte_data(i2c,reg,value);
 196         #endif
 197 out:
 198         mutex_unlock(&chip->io_lock);
 199         return ret;
 200 }
 201 EXPORT_SYMBOL(rt5025_assign_bits);
 202
 203 int rt5025_set_bits(struct i2c_client *i2c, int reg,
 204                 unsigned char mask)
 205 {
 206         return rt5025_assign_bits(i2c,reg,mask,mask);
 207 }
 208 EXPORT_SYMBOL(rt5025_set_bits);
 209
 210 int rt5025_clr_bits(struct i2c_client *i2c, int reg,
 211                 unsigned char mask)
 212 {
 213         return rt5025_assign_bits(i2c,reg,mask,0);
 214 }
 215 EXPORT_SYMBOL(rt5025_clr_bits);
 216
 217 static int __devinit rt5025_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
 218 {
 219         struct rt5025_platform_data *pdata = client->dev.platform_data;
 220         struct rt5025_chip *chip;
 221         int ret = 0;
 222         u8 val;
 223
 224         if (!pdata)
 225                 return -EINVAL;
 226
 227         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
 228         if (!chip)
 229                 return -ENOMEM;
 230
 231         chip->irq = client->irq;
 232         chip->i2c = client;
 233         chip->dev = &client->dev;
 234
 235 #if 0
 236         if (pdata->event_callback)
 237         {
 238                 chip->event_callback = kzalloc(sizeof(struct rt5025_event_callback), GFP_KERNEL);
 239                 memcpy(chip->event_callback, pdata->event_callback, sizeof(struct rt5025_event_callback));
 240         }
 241 #endif /* #if 0 */
 242
 243         i2c_set_clientdata(client, chip);
 244         mutex_init(&chip->io_lock);
 245
 246         rt5025_read_device(client,0x00,1,&val);
 247         if (val != 0x81){
 248                 printk("The PMIC is not RT5025\n");
 249                 return -ENODEV;
 250         }
 251         ret = rt5025_core_init(chip, pdata);
 252         if (ret < 0)
 253                 dev_err(chip->dev, "rt5025_core_init_fail\n");
 254         else
 255                 pr_info("RT5025 Initialize successfully\n");
 256
 257         if (pdata && pdata->pre_init) {
 258                 ret = pdata->pre_init(chip);
 259                 if (ret != 0) {
 260                         dev_err(chip->dev, "pre_init() failed: %d\n", ret);
 261                 }
 262         }
 263
 264         if (pdata && pdata->post_init) {
 265                 ret = pdata->post_init();
 266                 if (ret != 0) {
 267                         dev_err(chip->dev, "post_init() failed: %d\n", ret);
 268                 }
 269         }
 270
 271         return ret;
 272
 273 }
 274
 275 static int __devexit rt5025_i2c_remove(struct i2c_client *client)
 276 {
 277         struct rt5025_chip *chip = i2c_get_clientdata(client);
 278         rt5025_core_deinit(chip);
 279         #if 0
 280         if (chip->event_callback)
 281                 kfree(chip->event_callback);
 282         #endif
 283         kfree(chip);
 284         return 0;
 285 }
 286
 287 static int rt5025_i2c_suspend(struct i2c_client *client, pm_message_t mesg)
 288 {
 289         struct rt5025_chip *chip = i2c_get_clientdata(client);
 290         chip->suspend = 1;
 291         RTINFO("\n");
 292         return 0;
 293 }
 294
 295 static int rt5025_i2c_resume(struct i2c_client *client)
 296 {
 297         struct rt5025_chip *chip = i2c_get_clientdata(client);
 298         chip->suspend = 0;
 299         RTINFO("\n");
 300         return 0;
 301 }
 302
 303 static const struct i2c_device_id rt5025_id_table[] = {
 304         { RT5025_DEVICE_NAME, 0 },
 305         { },
 306 };
 307 MODULE_DEVICE_TABLE(i2c, rt5025_id_table);
 308
 309 static struct i2c_driver rt5025_driver = {
 310         .driver = {
 311                 .name   = RT5025_DEVICE_NAME,
 312                 .owner  = THIS_MODULE,
 313         },
 314         .probe          = rt5025_i2c_probe,
 315         .remove         = __devexit_p(rt5025_i2c_remove),
 316         .suspend        = rt5025_i2c_suspend,
 317         .resume         = rt5025_i2c_resume,
 318         .id_table       = rt5025_id_table,
 319 };
 320
 321 static int __init rt5025_i2c_init(void)
 322 {
 323         int ret;
 324
 325         ret = i2c_add_driver(&rt5025_driver);
 326         if (ret != 0)
 327                 pr_err("Failed to register RT5025 I2C driver: %d\n", ret);
 328         return ret;
 329 }
 330 subsys_initcall_sync(rt5025_i2c_init);
 331
 332 static void __exit rt5025_i2c_exit(void)
 333 {
 334         i2c_del_driver(&rt5025_driver);
 335 }
 336 module_exit(rt5025_i2c_exit);
 337
 338 MODULE_LICENSE("GPL v2");
 339 MODULE_DESCRIPTION("I2C Driver for Richtek RT5025");
 340 MODULE_AUTHOR("CY Huang <cy_huang@richtek.com>");
 341 MODULE_VERSION(RT5025_DRV_VER);