Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/drivers/mfd/max8925-i2c.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us