drivers/mfd/rt5036-i2c.c

   1 /*
   2  *  drivers/mfd/rt5036-i2c.c
   3  *  Source file for Richtek RT5036
   4  *
   5  *  Copyright (C) 2014 Richtek Technology Corp.
   6  *  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/init.h>
  17 #include <linux/i2c.h>
  18 #include <linux/mutex.h>
  19
  20 #include <linux/mfd/rt5036/rt5036.h>
  21
  22 static inline int rt5036_read_device(struct i2c_client *i2c,
  23                                      int reg, int bytes, void *dest)
  24 {
  25         int ret;
  26
  27         if (bytes > 1) {
  28                 ret = i2c_smbus_read_i2c_block_data(i2c, reg, bytes, dest);
  29         } else {
  30                 ret = i2c_smbus_read_byte_data(i2c, reg);
  31                 if (ret < 0)
  32                         return ret;
  33                 *(unsigned char *)dest = (unsigned char)ret;
  34         }
  35         return ret;
  36 }
  37
  38 int rt5036_reg_block_read(struct i2c_client *i2c,
  39                           int reg, int bytes, void *dest)
  40 {
  41         return rt5036_read_device(i2c, reg, bytes, dest);
  42 }
  43 EXPORT_SYMBOL(rt5036_reg_block_read);
  44
  45 static inline int rt5036_write_device(struct i2c_client *i2c,
  46                                       int reg, int bytes, void *dest)
  47 {
  48         int ret;
  49
  50         if (bytes > 1) {
  51                 ret = i2c_smbus_write_i2c_block_data(i2c, reg, bytes, dest);
  52         } else {
  53                 ret = i2c_smbus_write_byte_data(i2c, reg, *(u8 *) dest);
  54                 if (ret < 0)
  55                         return ret;
  56         }
  57         return ret;
  58 }
  59
  60 int rt5036_reg_block_write(struct i2c_client *i2c,
  61                            int reg, int bytes, void *dest)
  62 {
  63         return rt5036_write_device(i2c, reg, bytes, dest);
  64 }
  65 EXPORT_SYMBOL(rt5036_reg_block_write);
  66
  67 int rt5036_reg_read(struct i2c_client *i2c, int reg)
  68 {
  69         int ret;
  70
  71         RTINFO("I2C Read (client : 0x%x) reg = 0x%x\n",
  72                (unsigned int)i2c, (unsigned int)reg);
  73         ret = i2c_smbus_read_byte_data(i2c, reg);
  74         return ret;
  75 }
  76 EXPORT_SYMBOL(rt5036_reg_read);
  77
  78 int rt5036_reg_write(struct i2c_client *i2c, int reg, unsigned char data)
  79 {
  80         int ret;
  81
  82         RTINFO("I2C Write (client : 0x%x) reg = 0x%x, data = 0x%x\n",
  83                (unsigned int)i2c, (unsigned int)reg, (unsigned int)data);
  84         ret = i2c_smbus_write_byte_data(i2c, reg, data);
  85         return ret;
  86 }
  87 EXPORT_SYMBOL(rt5036_reg_write);
  88
  89 int rt5036_assign_bits(struct i2c_client *i2c, int reg,
  90                        unsigned char mask, unsigned char data)
  91 {
  92         unsigned char value;
  93         int ret;
  94
  95         ret = rt5036_read_device(i2c, reg, 1, &value);
  96
  97         if (ret < 0)
  98                 goto out;
  99         value &= ~mask;
 100         value |= (data & mask);
 101         ret = i2c_smbus_write_byte_data(i2c, reg, value);
 102 out:
 103         return ret;
 104 }
 105 EXPORT_SYMBOL(rt5036_assign_bits);
 106
 107 int rt5036_set_bits(struct i2c_client *i2c, int reg, unsigned char mask)
 108 {
 109         return rt5036_assign_bits(i2c, reg, mask, mask);
 110 }
 111 EXPORT_SYMBOL(rt5036_set_bits);
 112
 113 int rt5036_clr_bits(struct i2c_client *i2c, int reg, unsigned char mask)
 114 {
 115         return rt5036_assign_bits(i2c, reg, mask, 0);
 116 }
 117 EXPORT_SYMBOL(rt5036_clr_bits);
 118
 119 static int rt_parse_dt(struct rt5036_chip *chip, struct device *dev)
 120 {
 121         RTINFO("\n");
 122         return 0;
 123 }
 124
 125 static int rt_parse_pdata(struct rt5036_chip *chip,
 126                                     struct device *dev)
 127 {
 128         RTINFO("\n");
 129         return 0;
 130 }
 131
 132 static int rt5036_i2c_probe(struct i2c_client *client,
 133                                       const struct i2c_device_id *id)
 134 {
 135         struct rt5036_platform_data *pdata = client->dev.platform_data;
 136         struct rt5036_chip *chip;
 137         bool use_dt = client->dev.of_node;
 138         int val, ret = 0;
 139
 140         chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
 141         if (!chip)
 142                 return -ENOMEM;
 143
 144         chip->i2c = client;
 145         mutex_init(&chip->io_lock);
 146         i2c_set_clientdata(client, chip);
 147
 148         val = rt5036_reg_read(client, RT5036_REG_DEVID);
 149         if (val < 0) {
 150                 ret = -EIO;
 151                 goto out_err;
 152         } else {
 153                 if (val != 0x36) {
 154                         dev_err(&client->dev, "id 0x%02x is not correct\n",
 155                                 val);
 156                         ret = ENODEV;
 157                         goto out_err;
 158                 }
 159                 val = rt5036_reg_read(client, RT5036_REG_ONOFFEVENT);
 160                 dev_info(&client->dev, "last onoff event %02x\n", val);
 161                 /*set ldo lsw vrc to default enable*/
 162                 rt5036_reg_write(client, 0x4D, 0xF0);
 163                 rt5036_reg_write(client, 0x7D, 0xF0);
 164                 rt5036_reg_write(client, 0x85, 0xCC);
 165         }
 166
 167         if (use_dt) {
 168                 rt_parse_dt(chip, &client->dev);
 169         } else {
 170                 if (!pdata) {
 171                         dev_err(&client->dev, "no platform data included\n");
 172                         ret = -EINVAL;
 173                         goto out_err;
 174                 }
 175                 rt_parse_pdata(chip, &client->dev);
 176         }
 177
 178         ret = rt5036_core_init(&client->dev, pdata);
 179         if (ret < 0) {
 180                 ret = -EINVAL;
 181                 goto out_err;
 182         }
 183
 184         if (pdata && pdata->pre_init) {
 185                 ret = pdata->pre_init(chip);
 186                 if (ret != 0)
 187                         dev_err(&client->dev, "pre_init() failed: %d\n", ret);
 188         }
 189         if (pdata && pdata->post_init) {
 190                 ret = pdata->post_init();
 191                 if (ret != 0)
 192                         dev_err(&client->dev, "post_init() failed: %d\n", ret);
 193         }
 194         dev_info(&client->dev, "driver successfully loaded\n");
 195         return 0;
 196 out_err:
 197         return ret;
 198 }
 199
 200 static int rt5036_i2c_remove(struct i2c_client *client)
 201 {
 202         RTINFO("\n");
 203         rt5036_core_deinit(&client->dev);
 204         return 0;
 205 }
 206
 207 static int rt5036_i2c_suspend(struct device *dev)
 208 {
 209         struct i2c_client *i2c = container_of(dev, struct i2c_client, dev);
 210         struct rt5036_chip *chip = i2c_get_clientdata(i2c);
 211
 212         RTINFO("\n");
 213         chip->suspend = 1;
 214         return 0;
 215 }
 216
 217 static int rt5036_i2c_resume(struct device *dev)
 218 {
 219         struct i2c_client *i2c = container_of(dev, struct i2c_client, dev);
 220         struct rt5036_chip *chip = i2c_get_clientdata(i2c);
 221
 222         RTINFO("\n");
 223         chip->suspend = 0;
 224         return 0;
 225 }
 226
 227 static const struct dev_pm_ops rt5036_pm_ops = {
 228         .suspend = rt5036_i2c_suspend,
 229         .resume =  rt5036_i2c_resume,
 230 };
 231
 232 static const struct i2c_device_id rt5036_id_table[] = {
 233         {RT5036_DEV_NAME, 0},
 234         {},
 235 };
 236 MODULE_DEVICE_TABLE(i2c, rt5036_id_table);
 237
 238 static const struct of_device_id rt_match_table[] = {
 239         {.compatible = "rt,rt5036",},
 240         {},
 241 };
 242
 243 static struct i2c_driver rt5036_driver = {
 244         .driver = {
 245                    .name = RT5036_DEV_NAME,
 246                    .owner = THIS_MODULE,
 247                    .pm = &rt5036_pm_ops,
 248                    .of_match_table = rt_match_table,
 249                    },
 250         .probe = rt5036_i2c_probe,
 251         .remove = rt5036_i2c_remove,
 252         .id_table = rt5036_id_table,
 253 };
 254
 255 static int __init rt5036_i2c_init(void)
 256 {
 257         return i2c_add_driver(&rt5036_driver);
 258 }
 259 subsys_initcall_sync(rt5036_i2c_init);
 260
 261 static void __exit rt5036_i2c_exit(void)
 262 {
 263         i2c_del_driver(&rt5036_driver);
 264 }
 265 module_exit(rt5036_i2c_exit);
 266
 267 MODULE_LICENSE("GPL");
 268 MODULE_DESCRIPTION("I2C Driver for Richtek RT5036");
 269 MODULE_AUTHOR("CY Huang <cy_huang@richtek.com>");
 270 MODULE_VERSION(RT5036_DRV_VER);