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) 2014 Richtek Technology Corp.
   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; either version 2
  11  * of the License, or (at your option) any later version.
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/kernel.h>
  16 #include <linux/i2c.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
  24         if (bytes > 1) {
  25                 ret = i2c_smbus_read_i2c_block_data(i2c, reg, bytes, dest);
  26         } else {
  27                 ret = i2c_smbus_read_byte_data(i2c, reg);
  28                 if (ret < 0)
  29                         return ret;
  30                 *(unsigned char *)dest = (unsigned char)ret;
  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
  42 static inline int rt5025_write_device(struct i2c_client *i2c,
  43                                       int reg, int bytes, void *dest)
  44 {
  45         int ret;
  46
  47         if (bytes > 1) {
  48                 ret = i2c_smbus_write_i2c_block_data(i2c, reg, bytes, dest);
  49         } else {
  50                 ret = i2c_smbus_write_byte_data(i2c, reg, *(u8 *)dest);
  51                 if (ret < 0)
  52                         return ret;
  53         }
  54         return ret;
  55 }
  56
  57 int rt5025_reg_block_write(struct i2c_client *i2c, \
  58                         int reg, int bytes, void *dest)
  59 {
  60         return rt5025_write_device(i2c, reg, bytes, dest);
  61 }
  62 EXPORT_SYMBOL(rt5025_reg_block_write);
  63
  64 int rt5025_reg_read(struct i2c_client *i2c, int reg)
  65 {
  66         struct rt5025_chip *chip = i2c_get_clientdata(i2c);
  67         int ret;
  68
  69         RTINFO("I2C Read (client : 0x%x) reg = 0x%x\n",
  70                 (unsigned int) i2c, (unsigned int) reg);
  71         mutex_lock(&chip->io_lock);
  72         ret = i2c_smbus_read_byte_data(i2c, reg);
  73         mutex_unlock(&chip->io_lock);
  74         return ret;
  75 }
  76 EXPORT_SYMBOL(rt5025_reg_read);
  77
  78 int rt5025_reg_write(struct i2c_client *i2c, int reg, unsigned char data)
  79 {
  80         struct rt5025_chip *chip = i2c_get_clientdata(i2c);
  81         int ret;
  82
  83         RTINFO("I2C Write (client : 0x%x) reg = 0x%x, data = 0x%x\n",
  84                 (unsigned int) i2c, (unsigned int) reg, (unsigned int) data);
  85         mutex_lock(&chip->io_lock);
  86         ret = i2c_smbus_write_byte_data(i2c, reg, data);
  87         mutex_unlock(&chip->io_lock);
  88         return ret;
  89 }
  90 EXPORT_SYMBOL(rt5025_reg_write);
  91
  92 int rt5025_assign_bits(struct i2c_client *i2c, int reg,
  93                 unsigned char mask, unsigned char data)
  94 {
  95         struct rt5025_chip *chip = i2c_get_clientdata(i2c);
  96         unsigned char value;
  97         int ret;
  98
  99         mutex_lock(&chip->io_lock);
 100
 101         ret = rt5025_read_device(i2c, reg, 1, &value);
 102
 103         if (ret < 0)
 104                 goto out;
 105         value &= ~mask;
 106         value |= (data&mask);
 107         ret = i2c_smbus_write_byte_data(i2c, reg, value);
 108 out:
 109         mutex_unlock(&chip->io_lock);
 110         return ret;
 111 }
 112 EXPORT_SYMBOL(rt5025_assign_bits);
 113
 114 int rt5025_set_bits(struct i2c_client *i2c, int reg,
 115                 unsigned char mask)
 116 {
 117         return rt5025_assign_bits(i2c, reg, mask, mask);
 118 }
 119 EXPORT_SYMBOL(rt5025_set_bits);
 120
 121 int rt5025_clr_bits(struct i2c_client *i2c, int reg,
 122                 unsigned char mask)
 123 {
 124         return rt5025_assign_bits(i2c, reg, mask, 0);
 125 }
 126 EXPORT_SYMBOL(rt5025_clr_bits);
 127
 128 static int rt_parse_dt(struct rt5025_chip *chip, struct device *dev)
 129 {
 130         return 0;
 131 }
 132
 133 static int rt_parse_pdata(struct rt5025_chip *chip, struct device *dev)
 134 {
 135         return 0;
 136 }
 137
 138 static int rt5025_i2c_probe(struct i2c_client *client,
 139         const struct i2c_device_id *id)
 140 {
 141         struct rt5025_platform_data *pdata = client->dev.platform_data;
 142         struct rt5025_chip *chip;
 143         bool use_dt = client->dev.of_node;
 144         int ret = 0;
 145         u8 val = 0;
 146
 147         chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
 148         if (!chip)
 149                 return -ENOMEM;
 150
 151         if (use_dt) {
 152                 rt_parse_dt(chip, &client->dev);
 153         } else {
 154                 if (!pdata) {
 155                         ret = -EINVAL;
 156                         goto err_init;
 157                 }
 158                 rt_parse_pdata(chip, &client->dev);
 159         }
 160
 161         chip->i2c = client;
 162         chip->dev = &client->dev;
 163         mutex_init(&chip->io_lock);
 164         i2c_set_clientdata(client, chip);
 165         /* off event */
 166         rt5025_read_device(client, 0x20, 1, &val);
 167         RTINFO("off event = %d\n", val);
 168
 169         rt5025_read_device(client, 0x00, 1, &val);
 170         if (val != 0x81) {
 171                 dev_info(&client->dev, "The PMIC is not RT5025\n");
 172                 return -ENODEV;
 173         }
 174
 175         ret = rt5025_core_init(chip, pdata);
 176         if (ret < 0) {
 177                 dev_err(&client->dev, "rt5025_core_init_fail\n");
 178                 goto err_init;
 179         }
 180
 181         dev_info(&client->dev, "driver successfully probed\n");
 182         if (pdata && pdata->pre_init) {
 183                 ret = pdata->pre_init(chip);
 184                 if (ret != 0)
 185                         dev_err(chip->dev, "pre_init() failed: %d\n", ret);
 186         }
 187
 188         if (pdata && pdata->post_init) {
 189                 ret = pdata->post_init();
 190                 if (ret != 0)
 191                         dev_err(chip->dev, "post_init() failed: %d\n", ret);
 192         }
 193         return 0;
 194 err_init:
 195         return ret;
 196
 197 }
 198
 199 static int rt5025_i2c_remove(struct i2c_client *client)
 200 {
 201         struct rt5025_chip *chip = i2c_get_clientdata(client);
 202
 203         rt5025_core_deinit(chip);
 204         dev_info(&client->dev, "%s\n", __func__);
 205         return 0;
 206 }
 207
 208 static int rt5025_i2c_suspend(struct i2c_client *client, pm_message_t mesg)
 209 {
 210         struct rt5025_chip *chip = i2c_get_clientdata(client);
 211
 212         chip->suspend = 1;
 213         RTINFO("\n");
 214         return 0;
 215 }
 216
 217 static int rt5025_i2c_resume(struct i2c_client *client)
 218 {
 219         struct rt5025_chip *chip = i2c_get_clientdata(client);
 220
 221         chip->suspend = 0;
 222         RTINFO("\n");
 223         return 0;
 224 }
 225
 226 static const struct i2c_device_id rt5025_id_table[] = {
 227         { RT5025_DEV_NAME, 0 },
 228         { },
 229 };
 230 MODULE_DEVICE_TABLE(i2c, rt5025_id_table);
 231
 232 static struct of_device_id rt_match_table[] = {
 233         { .compatible = "rt,rt5025",},
 234         {},
 235 };
 236
 237 static struct i2c_driver rt5025_i2c_driver = {
 238         .driver = {
 239                 .name   = RT5025_DEV_NAME,
 240                 .owner  = THIS_MODULE,
 241                 .of_match_table = rt_match_table,
 242         },
 243         .probe          = rt5025_i2c_probe,
 244         .remove         = rt5025_i2c_remove,
 245         .suspend        = rt5025_i2c_suspend,
 246         .resume         = rt5025_i2c_resume,
 247         .id_table       = rt5025_id_table,
 248 };
 249
 250 static int rt5025_i2c_init(void)
 251 {
 252         return i2c_add_driver(&rt5025_i2c_driver);
 253 }
 254 subsys_initcall_sync(rt5025_i2c_init);
 255
 256 static void rt5025_i2c_exit(void)
 257 {
 258         i2c_del_driver(&rt5025_i2c_driver);
 259 }
 260 module_exit(rt5025_i2c_exit);
 261
 262 MODULE_LICENSE("GPL");
 263 MODULE_DESCRIPTION("I2C Driver for Richtek RT5025");
 264 MODULE_AUTHOR("CY Huang <cy_huang@richtek.com>");
 265 MODULE_VERSION(RT5025_DRV_VER);