misc: tegra-baseband: remove remote wakeup callback
[linux-3.10.git] / drivers / misc / bh1780gli.c
1 /*
2  * bh1780gli.c
3  * ROHM Ambient Light Sensor Driver
4  *
5  * Copyright (C) 2010 Texas Instruments
6  * Author: Hemanth V <hemanthv@ti.com>
7  *
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms of the GNU General Public License version 2 as published by
10  * the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but WITHOUT
13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
15  * more details.
16  *
17  * You should have received a copy of the GNU General Public License along with
18  * this program.  If not, see <http://www.gnu.org/licenses/>.
19  */
20 #include <linux/i2c.h>
21 #include <linux/slab.h>
22 #include <linux/mutex.h>
23 #include <linux/platform_device.h>
24 #include <linux/delay.h>
25 #include <linux/module.h>
26
27 #define BH1780_REG_CONTROL      0x80
28 #define BH1780_REG_PARTID       0x8A
29 #define BH1780_REG_MANFID       0x8B
30 #define BH1780_REG_DLOW 0x8C
31 #define BH1780_REG_DHIGH        0x8D
32
33 #define BH1780_REVMASK          (0xf)
34 #define BH1780_POWMASK          (0x3)
35 #define BH1780_POFF             (0x0)
36 #define BH1780_PON              (0x3)
37
38 /* power on settling time in ms */
39 #define BH1780_PON_DELAY        2
40
41 struct bh1780_data {
42         struct i2c_client *client;
43         int power_state;
44         /* lock for sysfs operations */
45         struct mutex lock;
46 };
47
48 static int bh1780_write(struct bh1780_data *ddata, u8 reg, u8 val, char *msg)
49 {
50         int ret = i2c_smbus_write_byte_data(ddata->client, reg, val);
51         if (ret < 0)
52                 dev_err(&ddata->client->dev,
53                         "i2c_smbus_write_byte_data failed error %d Register (%s)\n",
54                         ret, msg);
55         return ret;
56 }
57
58 static int bh1780_read(struct bh1780_data *ddata, u8 reg, char *msg)
59 {
60         int ret = i2c_smbus_read_byte_data(ddata->client, reg);
61         if (ret < 0)
62                 dev_err(&ddata->client->dev,
63                         "i2c_smbus_read_byte_data failed error %d Register (%s)\n",
64                         ret, msg);
65         return ret;
66 }
67
68 static ssize_t bh1780_show_lux(struct device *dev,
69                                 struct device_attribute *attr, char *buf)
70 {
71         struct platform_device *pdev = to_platform_device(dev);
72         struct bh1780_data *ddata = platform_get_drvdata(pdev);
73         int lsb, msb;
74
75         lsb = bh1780_read(ddata, BH1780_REG_DLOW, "DLOW");
76         if (lsb < 0)
77                 return lsb;
78
79         msb = bh1780_read(ddata, BH1780_REG_DHIGH, "DHIGH");
80         if (msb < 0)
81                 return msb;
82
83         return sprintf(buf, "%d\n", (msb << 8) | lsb);
84 }
85
86 static ssize_t bh1780_show_power_state(struct device *dev,
87                                         struct device_attribute *attr,
88                                         char *buf)
89 {
90         struct platform_device *pdev = to_platform_device(dev);
91         struct bh1780_data *ddata = platform_get_drvdata(pdev);
92         int state;
93
94         state = bh1780_read(ddata, BH1780_REG_CONTROL, "CONTROL");
95         if (state < 0)
96                 return state;
97
98         return sprintf(buf, "%d\n", state & BH1780_POWMASK);
99 }
100
101 static ssize_t bh1780_store_power_state(struct device *dev,
102                                         struct device_attribute *attr,
103                                         const char *buf, size_t count)
104 {
105         struct platform_device *pdev = to_platform_device(dev);
106         struct bh1780_data *ddata = platform_get_drvdata(pdev);
107         unsigned long val;
108         int error;
109
110         error = strict_strtoul(buf, 0, &val);
111         if (error)
112                 return error;
113
114         if (val < BH1780_POFF || val > BH1780_PON)
115                 return -EINVAL;
116
117         mutex_lock(&ddata->lock);
118
119         error = bh1780_write(ddata, BH1780_REG_CONTROL, val, "CONTROL");
120         if (error < 0) {
121                 mutex_unlock(&ddata->lock);
122                 return error;
123         }
124
125         msleep(BH1780_PON_DELAY);
126         ddata->power_state = val;
127         mutex_unlock(&ddata->lock);
128
129         return count;
130 }
131
132 static DEVICE_ATTR(lux, S_IRUGO, bh1780_show_lux, NULL);
133
134 static DEVICE_ATTR(power_state, S_IWUSR | S_IRUGO,
135                 bh1780_show_power_state, bh1780_store_power_state);
136
137 static struct attribute *bh1780_attributes[] = {
138         &dev_attr_power_state.attr,
139         &dev_attr_lux.attr,
140         NULL
141 };
142
143 static const struct attribute_group bh1780_attr_group = {
144         .attrs = bh1780_attributes,
145 };
146
147 static int bh1780_probe(struct i2c_client *client,
148                                                 const struct i2c_device_id *id)
149 {
150         int ret;
151         struct bh1780_data *ddata = NULL;
152         struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
153
154         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE)) {
155                 ret = -EIO;
156                 goto err_op_failed;
157         }
158
159         ddata = kzalloc(sizeof(struct bh1780_data), GFP_KERNEL);
160         if (ddata == NULL) {
161                 ret = -ENOMEM;
162                 goto err_op_failed;
163         }
164
165         ddata->client = client;
166         i2c_set_clientdata(client, ddata);
167
168         ret = bh1780_read(ddata, BH1780_REG_PARTID, "PART ID");
169         if (ret < 0)
170                 goto err_op_failed;
171
172         dev_info(&client->dev, "Ambient Light Sensor, Rev : %d\n",
173                         (ret & BH1780_REVMASK));
174
175         mutex_init(&ddata->lock);
176
177         ret = sysfs_create_group(&client->dev.kobj, &bh1780_attr_group);
178         if (ret)
179                 goto err_op_failed;
180
181         return 0;
182
183 err_op_failed:
184         kfree(ddata);
185         return ret;
186 }
187
188 static int bh1780_remove(struct i2c_client *client)
189 {
190         struct bh1780_data *ddata;
191
192         ddata = i2c_get_clientdata(client);
193         sysfs_remove_group(&client->dev.kobj, &bh1780_attr_group);
194         kfree(ddata);
195
196         return 0;
197 }
198
199 #ifdef CONFIG_PM_SLEEP
200 static int bh1780_suspend(struct device *dev)
201 {
202         struct bh1780_data *ddata;
203         int state, ret;
204         struct i2c_client *client = to_i2c_client(dev);
205
206         ddata = i2c_get_clientdata(client);
207         state = bh1780_read(ddata, BH1780_REG_CONTROL, "CONTROL");
208         if (state < 0)
209                 return state;
210
211         ddata->power_state = state & BH1780_POWMASK;
212
213         ret = bh1780_write(ddata, BH1780_REG_CONTROL, BH1780_POFF,
214                                 "CONTROL");
215
216         if (ret < 0)
217                 return ret;
218
219         return 0;
220 }
221
222 static int bh1780_resume(struct device *dev)
223 {
224         struct bh1780_data *ddata;
225         int state, ret;
226         struct i2c_client *client = to_i2c_client(dev);
227
228         ddata = i2c_get_clientdata(client);
229         state = ddata->power_state;
230         ret = bh1780_write(ddata, BH1780_REG_CONTROL, state,
231                                 "CONTROL");
232
233         if (ret < 0)
234                 return ret;
235
236         return 0;
237 }
238 #endif /* CONFIG_PM_SLEEP */
239
240 static SIMPLE_DEV_PM_OPS(bh1780_pm, bh1780_suspend, bh1780_resume);
241
242 static const struct i2c_device_id bh1780_id[] = {
243         { "bh1780", 0 },
244         { },
245 };
246
247 static struct i2c_driver bh1780_driver = {
248         .probe          = bh1780_probe,
249         .remove         = bh1780_remove,
250         .id_table       = bh1780_id,
251         .driver = {
252                 .name = "bh1780",
253                 .pm     = &bh1780_pm,
254         },
255 };
256
257 module_i2c_driver(bh1780_driver);
258
259 MODULE_DESCRIPTION("BH1780GLI Ambient Light Sensor Driver");
260 MODULE_LICENSE("GPL");
261 MODULE_AUTHOR("Hemanth V <hemanthv@ti.com>");