drivers/mfd/max8925-i2c.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * I2C driver for Maxim MAX8925
0004  *
0005  * Copyright (C) 2009 Marvell International Ltd.
0006  *  Haojian Zhuang <haojian.zhuang@marvell.com>
0007  */
0008 #include <linux/kernel.h>
0009 #include <linux/init.h>
0010 #include <linux/platform_device.h>
0011 #include <linux/i2c.h>
0012 #include <linux/mfd/max8925.h>
0013 #include <linux/slab.h>
0014
0015 #define RTC_I2C_ADDR        0x68
0016 #define ADC_I2C_ADDR        0x47
0017
0018 static inline int max8925_read_device(struct i2c_client *i2c,
0019                       int reg, int bytes, void *dest)
0020 {
0021     int ret;
0022
0023     if (bytes > 1)
0024         ret = i2c_smbus_read_i2c_block_data(i2c, reg, bytes, dest);
0025     else {
0026         ret = i2c_smbus_read_byte_data(i2c, reg);
0027         if (ret < 0)
0028             return ret;
0029         *(unsigned char *)dest = (unsigned char)ret;
0030     }
0031     return ret;
0032 }
0033
0034 static inline int max8925_write_device(struct i2c_client *i2c,
0035                        int reg, int bytes, void *src)
0036 {
0037     unsigned char buf[9];
0038     int ret;
0039
0040     buf[0] = (unsigned char)reg;
0041     memcpy(&buf[1], src, bytes);
0042
0043     ret = i2c_master_send(i2c, buf, bytes + 1);
0044     if (ret < 0)
0045         return ret;
0046     return 0;
0047 }
0048
0049 int max8925_reg_read(struct i2c_client *i2c, int reg)
0050 {
0051     struct max8925_chip *chip = i2c_get_clientdata(i2c);
0052     unsigned char data = 0;
0053     int ret;
0054
0055     mutex_lock(&chip->io_lock);
0056     ret = max8925_read_device(i2c, reg, 1, &data);
0057     mutex_unlock(&chip->io_lock);
0058
0059     if (ret < 0)
0060         return ret;
0061     else
0062         return (int)data;
0063 }
0064 EXPORT_SYMBOL(max8925_reg_read);
0065
0066 int max8925_reg_write(struct i2c_client *i2c, int reg,
0067         unsigned char data)
0068 {
0069     struct max8925_chip *chip = i2c_get_clientdata(i2c);
0070     int ret;
0071
0072     mutex_lock(&chip->io_lock);
0073     ret = max8925_write_device(i2c, reg, 1, &data);
0074     mutex_unlock(&chip->io_lock);
0075
0076     return ret;
0077 }
0078 EXPORT_SYMBOL(max8925_reg_write);
0079
0080 int max8925_bulk_read(struct i2c_client *i2c, int reg,
0081         int count, unsigned char *buf)
0082 {
0083     struct max8925_chip *chip = i2c_get_clientdata(i2c);
0084     int ret;
0085
0086     mutex_lock(&chip->io_lock);
0087     ret = max8925_read_device(i2c, reg, count, buf);
0088     mutex_unlock(&chip->io_lock);
0089
0090     return ret;
0091 }
0092 EXPORT_SYMBOL(max8925_bulk_read);
0093
0094 int max8925_bulk_write(struct i2c_client *i2c, int reg,
0095         int count, unsigned char *buf)
0096 {
0097     struct max8925_chip *chip = i2c_get_clientdata(i2c);
0098     int ret;
0099
0100     mutex_lock(&chip->io_lock);
0101     ret = max8925_write_device(i2c, reg, count, buf);
0102     mutex_unlock(&chip->io_lock);
0103
0104     return ret;
0105 }
0106 EXPORT_SYMBOL(max8925_bulk_write);
0107
0108 int max8925_set_bits(struct i2c_client *i2c, int reg,
0109         unsigned char mask, unsigned char data)
0110 {
0111     struct max8925_chip *chip = i2c_get_clientdata(i2c);
0112     unsigned char value;
0113     int ret;
0114
0115     mutex_lock(&chip->io_lock);
0116     ret = max8925_read_device(i2c, reg, 1, &value);
0117     if (ret < 0)
0118         goto out;
0119     value &= ~mask;
0120     value |= data;
0121     ret = max8925_write_device(i2c, reg, 1, &value);
0122 out:
0123     mutex_unlock(&chip->io_lock);
0124     return ret;
0125 }
0126 EXPORT_SYMBOL(max8925_set_bits);
0127
0128
0129 static const struct i2c_device_id max8925_id_table[] = {
0130     { "max8925", 0 },
0131     { },
0132 };
0133
0134 static int max8925_dt_init(struct device_node *np, struct device *dev,
0135                struct max8925_platform_data *pdata)
0136 {
0137     int ret;
0138
0139     ret = of_property_read_u32(np, "maxim,tsc-irq", &pdata->tsc_irq);
0140     if (ret) {
0141         dev_err(dev, "Not found maxim,tsc-irq property\n");
0142         return -EINVAL;
0143     }
0144     return 0;
0145 }
0146
0147 static int max8925_probe(struct i2c_client *client,
0148                    const struct i2c_device_id *id)
0149 {
0150     struct max8925_platform_data *pdata = dev_get_platdata(&client->dev);
0151     struct max8925_chip *chip;
0152     struct device_node *node = client->dev.of_node;
0153
0154     if (node && !pdata) {
0155         /* parse DT to get platform data */
0156         pdata = devm_kzalloc(&client->dev,
0157                      sizeof(struct max8925_platform_data),
0158                      GFP_KERNEL);
0159         if (!pdata)
0160             return -ENOMEM;
0161
0162         if (max8925_dt_init(node, &client->dev, pdata))
0163             return -EINVAL;
0164     } else if (!pdata) {
0165         pr_info("%s: platform data is missing\n", __func__);
0166         return -EINVAL;
0167     }
0168
0169     chip = devm_kzalloc(&client->dev,
0170                 sizeof(struct max8925_chip), GFP_KERNEL);
0171     if (chip == NULL)
0172         return -ENOMEM;
0173     chip->i2c = client;
0174     chip->dev = &client->dev;
0175     i2c_set_clientdata(client, chip);
0176     dev_set_drvdata(chip->dev, chip);
0177     mutex_init(&chip->io_lock);
0178
0179     chip->rtc = i2c_new_dummy_device(chip->i2c->adapter, RTC_I2C_ADDR);
0180     if (IS_ERR(chip->rtc)) {
0181         dev_err(chip->dev, "Failed to allocate I2C device for RTC\n");
0182         return PTR_ERR(chip->rtc);
0183     }
0184     i2c_set_clientdata(chip->rtc, chip);
0185
0186     chip->adc = i2c_new_dummy_device(chip->i2c->adapter, ADC_I2C_ADDR);
0187     if (IS_ERR(chip->adc)) {
0188         dev_err(chip->dev, "Failed to allocate I2C device for ADC\n");
0189         i2c_unregister_device(chip->rtc);
0190         return PTR_ERR(chip->adc);
0191     }
0192     i2c_set_clientdata(chip->adc, chip);
0193
0194     device_init_wakeup(&client->dev, 1);
0195
0196     max8925_device_init(chip, pdata);
0197
0198     return 0;
0199 }
0200
0201 static int max8925_remove(struct i2c_client *client)
0202 {
0203     struct max8925_chip *chip = i2c_get_clientdata(client);
0204
0205     max8925_device_exit(chip);
0206     i2c_unregister_device(chip->adc);
0207     i2c_unregister_device(chip->rtc);
0208     return 0;
0209 }
0210
0211 #ifdef CONFIG_PM_SLEEP
0212 static int max8925_suspend(struct device *dev)
0213 {
0214     struct i2c_client *client = to_i2c_client(dev);
0215     struct max8925_chip *chip = i2c_get_clientdata(client);
0216
0217     if (device_may_wakeup(dev) && chip->wakeup_flag)
0218         enable_irq_wake(chip->core_irq);
0219     return 0;
0220 }
0221
0222 static int max8925_resume(struct device *dev)
0223 {
0224     struct i2c_client *client = to_i2c_client(dev);
0225     struct max8925_chip *chip = i2c_get_clientdata(client);
0226
0227     if (device_may_wakeup(dev) && chip->wakeup_flag)
0228         disable_irq_wake(chip->core_irq);
0229     return 0;
0230 }
0231 #endif
0232
0233 static SIMPLE_DEV_PM_OPS(max8925_pm_ops, max8925_suspend, max8925_resume);
0234
0235 static const struct of_device_id max8925_dt_ids[] = {
0236     { .compatible = "maxim,max8925", },
0237     {},
0238 };
0239
0240 static struct i2c_driver max8925_driver = {
0241     .driver = {
0242         .name   = "max8925",
0243         .pm     = &max8925_pm_ops,
0244         .of_match_table = max8925_dt_ids,
0245     },
0246     .probe      = max8925_probe,
0247     .remove     = max8925_remove,
0248     .id_table   = max8925_id_table,
0249 };
0250
0251 static int __init max8925_i2c_init(void)
0252 {
0253     int ret;
0254
0255     ret = i2c_add_driver(&max8925_driver);
0256     if (ret != 0)
0257         pr_err("Failed to register MAX8925 I2C driver: %d\n", ret);
0258
0259     return ret;
0260 }
0261 subsys_initcall(max8925_i2c_init);