GNU Linux-libre 5.10.219-gnu1
[releases.git] / drivers / mfd / max8925-i2c.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * I2C driver for Maxim MAX8925
4  *
5  * Copyright (C) 2009 Marvell International Ltd.
6  *      Haojian Zhuang <haojian.zhuang@marvell.com>
7  */
8 #include <linux/kernel.h>
9 #include <linux/init.h>
10 #include <linux/platform_device.h>
11 #include <linux/i2c.h>
12 #include <linux/mfd/max8925.h>
13 #include <linux/slab.h>
14
15 #define RTC_I2C_ADDR            0x68
16 #define ADC_I2C_ADDR            0x47
17
18 static inline int max8925_read_device(struct i2c_client *i2c,
19                                       int reg, int bytes, void *dest)
20 {
21         int ret;
22
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         return ret;
32 }
33
34 static inline int max8925_write_device(struct i2c_client *i2c,
35                                        int reg, int bytes, void *src)
36 {
37         unsigned char buf[9];
38         int ret;
39
40         buf[0] = (unsigned char)reg;
41         memcpy(&buf[1], src, bytes);
42
43         ret = i2c_master_send(i2c, buf, bytes + 1);
44         if (ret < 0)
45                 return ret;
46         return 0;
47 }
48
49 int max8925_reg_read(struct i2c_client *i2c, int reg)
50 {
51         struct max8925_chip *chip = i2c_get_clientdata(i2c);
52         unsigned char data = 0;
53         int ret;
54
55         mutex_lock(&chip->io_lock);
56         ret = max8925_read_device(i2c, reg, 1, &data);
57         mutex_unlock(&chip->io_lock);
58
59         if (ret < 0)
60                 return ret;
61         else
62                 return (int)data;
63 }
64 EXPORT_SYMBOL(max8925_reg_read);
65
66 int max8925_reg_write(struct i2c_client *i2c, int reg,
67                 unsigned char data)
68 {
69         struct max8925_chip *chip = i2c_get_clientdata(i2c);
70         int ret;
71
72         mutex_lock(&chip->io_lock);
73         ret = max8925_write_device(i2c, reg, 1, &data);
74         mutex_unlock(&chip->io_lock);
75
76         return ret;
77 }
78 EXPORT_SYMBOL(max8925_reg_write);
79
80 int max8925_bulk_read(struct i2c_client *i2c, int reg,
81                 int count, unsigned char *buf)
82 {
83         struct max8925_chip *chip = i2c_get_clientdata(i2c);
84         int ret;
85
86         mutex_lock(&chip->io_lock);
87         ret = max8925_read_device(i2c, reg, count, buf);
88         mutex_unlock(&chip->io_lock);
89
90         return ret;
91 }
92 EXPORT_SYMBOL(max8925_bulk_read);
93
94 int max8925_bulk_write(struct i2c_client *i2c, int reg,
95                 int count, unsigned char *buf)
96 {
97         struct max8925_chip *chip = i2c_get_clientdata(i2c);
98         int ret;
99
100         mutex_lock(&chip->io_lock);
101         ret = max8925_write_device(i2c, reg, count, buf);
102         mutex_unlock(&chip->io_lock);
103
104         return ret;
105 }
106 EXPORT_SYMBOL(max8925_bulk_write);
107
108 int max8925_set_bits(struct i2c_client *i2c, int reg,
109                 unsigned char mask, unsigned char data)
110 {
111         struct max8925_chip *chip = i2c_get_clientdata(i2c);
112         unsigned char value;
113         int ret;
114
115         mutex_lock(&chip->io_lock);
116         ret = max8925_read_device(i2c, reg, 1, &value);
117         if (ret < 0)
118                 goto out;
119         value &= ~mask;
120         value |= data;
121         ret = max8925_write_device(i2c, reg, 1, &value);
122 out:
123         mutex_unlock(&chip->io_lock);
124         return ret;
125 }
126 EXPORT_SYMBOL(max8925_set_bits);
127
128
129 static const struct i2c_device_id max8925_id_table[] = {
130         { "max8925", 0 },
131         { },
132 };
133
134 static int max8925_dt_init(struct device_node *np, struct device *dev,
135                            struct max8925_platform_data *pdata)
136 {
137         int ret;
138
139         ret = of_property_read_u32(np, "maxim,tsc-irq", &pdata->tsc_irq);
140         if (ret) {
141                 dev_err(dev, "Not found maxim,tsc-irq property\n");
142                 return -EINVAL;
143         }
144         return 0;
145 }
146
147 static int max8925_probe(struct i2c_client *client,
148                                    const struct i2c_device_id *id)
149 {
150         struct max8925_platform_data *pdata = dev_get_platdata(&client->dev);
151         struct max8925_chip *chip;
152         struct device_node *node = client->dev.of_node;
153
154         if (node && !pdata) {
155                 /* parse DT to get platform data */
156                 pdata = devm_kzalloc(&client->dev,
157                                      sizeof(struct max8925_platform_data),
158                                      GFP_KERNEL);
159                 if (!pdata)
160                         return -ENOMEM;
161
162                 if (max8925_dt_init(node, &client->dev, pdata))
163                         return -EINVAL;
164         } else if (!pdata) {
165                 pr_info("%s: platform data is missing\n", __func__);
166                 return -EINVAL;
167         }
168
169         chip = devm_kzalloc(&client->dev,
170                             sizeof(struct max8925_chip), GFP_KERNEL);
171         if (chip == NULL)
172                 return -ENOMEM;
173         chip->i2c = client;
174         chip->dev = &client->dev;
175         i2c_set_clientdata(client, chip);
176         dev_set_drvdata(chip->dev, chip);
177         mutex_init(&chip->io_lock);
178
179         chip->rtc = i2c_new_dummy_device(chip->i2c->adapter, RTC_I2C_ADDR);
180         if (IS_ERR(chip->rtc)) {
181                 dev_err(chip->dev, "Failed to allocate I2C device for RTC\n");
182                 return PTR_ERR(chip->rtc);
183         }
184         i2c_set_clientdata(chip->rtc, chip);
185
186         chip->adc = i2c_new_dummy_device(chip->i2c->adapter, ADC_I2C_ADDR);
187         if (IS_ERR(chip->adc)) {
188                 dev_err(chip->dev, "Failed to allocate I2C device for ADC\n");
189                 i2c_unregister_device(chip->rtc);
190                 return PTR_ERR(chip->adc);
191         }
192         i2c_set_clientdata(chip->adc, chip);
193
194         device_init_wakeup(&client->dev, 1);
195
196         max8925_device_init(chip, pdata);
197
198         return 0;
199 }
200
201 static int max8925_remove(struct i2c_client *client)
202 {
203         struct max8925_chip *chip = i2c_get_clientdata(client);
204
205         max8925_device_exit(chip);
206         i2c_unregister_device(chip->adc);
207         i2c_unregister_device(chip->rtc);
208         return 0;
209 }
210
211 #ifdef CONFIG_PM_SLEEP
212 static int max8925_suspend(struct device *dev)
213 {
214         struct i2c_client *client = to_i2c_client(dev);
215         struct max8925_chip *chip = i2c_get_clientdata(client);
216
217         if (device_may_wakeup(dev) && chip->wakeup_flag)
218                 enable_irq_wake(chip->core_irq);
219         return 0;
220 }
221
222 static int max8925_resume(struct device *dev)
223 {
224         struct i2c_client *client = to_i2c_client(dev);
225         struct max8925_chip *chip = i2c_get_clientdata(client);
226
227         if (device_may_wakeup(dev) && chip->wakeup_flag)
228                 disable_irq_wake(chip->core_irq);
229         return 0;
230 }
231 #endif
232
233 static SIMPLE_DEV_PM_OPS(max8925_pm_ops, max8925_suspend, max8925_resume);
234
235 static const struct of_device_id max8925_dt_ids[] = {
236         { .compatible = "maxim,max8925", },
237         {},
238 };
239
240 static struct i2c_driver max8925_driver = {
241         .driver = {
242                 .name   = "max8925",
243                 .pm     = &max8925_pm_ops,
244                 .of_match_table = max8925_dt_ids,
245         },
246         .probe          = max8925_probe,
247         .remove         = max8925_remove,
248         .id_table       = max8925_id_table,
249 };
250
251 static int __init max8925_i2c_init(void)
252 {
253         int ret;
254
255         ret = i2c_add_driver(&max8925_driver);
256         if (ret != 0)
257                 pr_err("Failed to register MAX8925 I2C driver: %d\n", ret);
258
259         return ret;
260 }
261 subsys_initcall(max8925_i2c_init);