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 static inline int rt5025_read_device(struct i2c_client *i2c,
  20                                       int reg, int bytes, void *dest)
  21 {
  22         int ret;
  23         if (bytes > 1)
  24                 ret = i2c_smbus_read_i2c_block_data(i2c, reg, bytes, dest);
  25         else {
  26                 ret = i2c_smbus_read_byte_data(i2c, reg);
  27                 if (ret < 0)
  28                         return ret;
  29                 *(unsigned char *)dest = (unsigned char)ret;
  30         }
  31
  32         return ret;
  33 }
  34
  35 int rt5025_reg_block_read(struct i2c_client *i2c, \
  36                         int reg, int bytes, void *dest)
  37 {
  38         return rt5025_read_device(i2c, reg, bytes, dest);
  39 }
  40 EXPORT_SYMBOL(rt5025_reg_block_read);
  41 #if 0
  42 int rt5025_reg_read(struct i2c_client *i2c, int reg)
  43 {
  44         struct rt5025_chip* chip = i2c_get_clientdata(i2c);
  45         int ret;
  46         RTINFO("I2C Read (client : 0x%x) reg = 0x%x\n",
  47            (unsigned int)i2c,(unsigned int)reg);
  48         mutex_lock(&chip->io_lock);
  49         ret = i2c_smbus_read_byte_data(i2c, reg);
  50         mutex_unlock(&chip->io_lock);
  51         return ret;
  52 }
  53 EXPORT_SYMBOL(rt5025_reg_read);
  54
  55 int rt5025_reg_write(struct i2c_client *i2c, int reg, unsigned char data)
  56 {
  57         struct rt5025_chip* chip = i2c_get_clientdata(i2c);
  58         int ret;
  59         printk("%s,line=%d\n", __func__,__LINE__);
  60
  61 //      RTINFO("I2C Write (client : 0x%x) reg = 0x%x, data = 0x%x\n",
  62  //          (unsigned int)i2c,(unsigned int)reg,(unsigned int)data);
  63         mutex_lock(&chip->io_lock);
  64 printk("%s,line=%d \n", __func__,__LINE__);
  65
  66         ret = i2c_smbus_write_byte_data(i2c, reg, data);
  67         mutex_unlock(&chip->io_lock);
  68         printk("%s,line=%d %d \n", __func__,__LINE__,ret);
  69
  70         return ret;
  71 }
  72 EXPORT_SYMBOL(rt5025_reg_write);
  73 #else
  74 int rt5025_reg_read(struct i2c_client *i2c, int reg)
  75 {
  76     struct i2c_adapter *adap;
  77     struct i2c_msg msgs[2];
  78     int ret;
  79     unsigned char *dest;
  80     u8 val;
  81
  82     dest = &val;
  83
  84     if(!i2c)
  85                 return ret;
  86
  87     adap = i2c->adapter;
  88
  89     msgs[0].addr = i2c->addr;
  90     msgs[0].buf = &reg;
  91     msgs[0].flags = i2c->flags;
  92     msgs[0].len = 1;
  93     msgs[0].scl_rate = 200*1000;
  94
  95      msgs[1].buf = dest;
  96     msgs[1].addr = i2c->addr;
  97     msgs[1].flags = i2c->flags | I2C_M_RD;
  98     msgs[1].len = 1;
  99     msgs[1].scl_rate = 200*1000;
 100     ret = i2c_transfer(adap, msgs, 2);
 101
 102 //      printk("***run in %s %d msgs[1].buf = %d\n",__FUNCTION__,__LINE__,*(msgs[1].buf));
 103
 104         return val;
 105 }
 106 EXPORT_SYMBOL(rt5025_reg_read);
 107
 108 int rt5025_reg_write(struct i2c_client *i2c, int reg, unsigned char data)
 109 {
 110
 111         int ret=-1;
 112
 113         struct i2c_adapter *adap;
 114         struct i2c_msg msg;
 115         char tx_buf[2];
 116
 117         if(!i2c)
 118                 return ret;
 119
 120         adap = i2c->adapter;
 121         tx_buf[0] = reg;
 122         tx_buf[1] = data;
 123
 124         msg.addr = i2c->addr;
 125         msg.buf = &tx_buf[0];
 126         msg.len = 1 +1;
 127         msg.flags = i2c->flags;
 128         msg.scl_rate = 200*1000;
 129
 130         ret = i2c_transfer(adap, &msg, 1);
 131         return ret;
 132 }
 133 EXPORT_SYMBOL(rt5025_reg_write);
 134 #endif
 135 int rt5025_assign_bits(struct i2c_client *i2c, int reg,
 136                 unsigned char mask, unsigned char data)
 137 {
 138         struct rt5025_chip *chip = i2c_get_clientdata(i2c);
 139         unsigned char value;
 140         int ret;
 141         mutex_lock(&chip->io_lock);
 142
 143         ret = rt5025_read_device(i2c, reg, 1, &value);
 144
 145         if (ret < 0)
 146                 goto out;
 147         value &= ~mask;
 148         value |= (data&mask);
 149         ret = rt5025_reg_write(i2c,reg,value);
 150 out:
 151         mutex_unlock(&chip->io_lock);
 152         return ret;
 153 }
 154 EXPORT_SYMBOL(rt5025_assign_bits);
 155
 156 int rt5025_set_bits(struct i2c_client *i2c, int reg,
 157                 unsigned char mask)
 158 {
 159         return rt5025_assign_bits(i2c,reg,mask,mask);
 160 }
 161 EXPORT_SYMBOL(rt5025_set_bits);
 162
 163 int rt5025_clr_bits(struct i2c_client *i2c, int reg,
 164                 unsigned char mask)
 165 {
 166         return rt5025_assign_bits(i2c,reg,mask,0);
 167 }
 168 EXPORT_SYMBOL(rt5025_clr_bits);
 169
 170 static int __devinit rt5025_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
 171 {
 172         struct rt5025_platform_data *pdata = client->dev.platform_data;
 173         struct rt5025_chip *chip;
 174         int ret = 0;
 175         u8 val;
 176
 177         if (!pdata)
 178                 return -EINVAL;
 179
 180         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
 181         if (!chip)
 182                 return -ENOMEM;
 183
 184         chip->irq = client->irq;
 185         chip->i2c = client;
 186         chip->dev = &client->dev;
 187
 188 #if 0
 189         if (pdata->event_callback)
 190         {
 191                 chip->event_callback = kzalloc(sizeof(struct rt5025_event_callback), GFP_KERNEL);
 192                 memcpy(chip->event_callback, pdata->event_callback, sizeof(struct rt5025_event_callback));
 193         }
 194 #endif /* #if 0 */
 195
 196         i2c_set_clientdata(client, chip);
 197         mutex_init(&chip->io_lock);
 198
 199         rt5025_read_device(client,0x00,1,&val);
 200         if (val != 0x81){
 201         printk("The PMIC is not RT5025\n");
 202         return 0;
 203         }
 204         ret = rt5025_core_init(chip, pdata);
 205         if (ret < 0)
 206                 dev_err(chip->dev, "rt5025_core_init_fail\n");
 207         else
 208                 pr_info("RT5025 Initialize successfully\n");
 209
 210         if (pdata && pdata->pre_init) {
 211                 ret = pdata->pre_init(chip);
 212                 if (ret != 0) {
 213                         dev_err(chip->dev, "pre_init() failed: %d\n", ret);
 214                 }
 215         }
 216
 217         if (pdata && pdata->post_init) {
 218                 ret = pdata->post_init();
 219                 if (ret != 0) {
 220                         dev_err(chip->dev, "post_init() failed: %d\n", ret);
 221                 }
 222         }
 223
 224         return ret;
 225
 226 }
 227
 228 static int __devexit rt5025_i2c_remove(struct i2c_client *client)
 229 {
 230         struct rt5025_chip *chip = i2c_get_clientdata(client);
 231         rt5025_core_deinit(chip);
 232         #if 0
 233         if (chip->event_callback)
 234                 kfree(chip->event_callback);a
 235         #endif
 236         kfree(chip);
 237         return 0;
 238 }
 239
 240 static int rt5025_i2c_suspend(struct i2c_client *client, pm_message_t mesg)
 241 {
 242         struct rt5025_chip *chip = i2c_get_clientdata(client);
 243         chip->suspend = 1;
 244         return 0;
 245 }
 246
 247 static int rt5025_i2c_resume(struct i2c_client *client)
 248 {
 249         struct rt5025_chip *chip = i2c_get_clientdata(client);
 250         chip->suspend = 0;
 251         return 0;
 252 }
 253
 254 static const struct i2c_device_id rt5025_id_table[] = {
 255         { RT5025_DEVICE_NAME, 0 },
 256         { },
 257 };
 258 MODULE_DEVICE_TABLE(i2c, rt5025_id_table);
 259
 260 static struct i2c_driver rt5025_driver = {
 261         .driver = {
 262                 .name   = RT5025_DEVICE_NAME,
 263                 .owner  = THIS_MODULE,
 264         },
 265         .probe          = rt5025_i2c_probe,
 266         .remove         = __devexit_p(rt5025_i2c_remove),
 267         .suspend        = rt5025_i2c_suspend,
 268         .resume         = rt5025_i2c_resume,
 269         .id_table       = rt5025_id_table,
 270 };
 271
 272 static int __init rt5025_i2c_init(void)
 273 {
 274         int ret;
 275
 276         ret = i2c_add_driver(&rt5025_driver);
 277         if (ret != 0)
 278                 pr_err("Failed to register RT5025 I2C driver: %d\n", ret);
 279         return ret;
 280 }
 281 subsys_initcall_sync(rt5025_i2c_init);
 282
 283 static void __exit rt5025_i2c_exit(void)
 284 {
 285         i2c_del_driver(&rt5025_driver);
 286 }
 287 module_exit(rt5025_i2c_exit);
 288
 289 MODULE_LICENSE("GPL v2");
 290 MODULE_DESCRIPTION("I2C Driver for Richtek RT5025");
 291 MODULE_AUTHOR("CY Huang <cy_huang@richtek.com>");