]>
Commit | Line | Data |
---|---|---|
b4ecd326 RV |
1 | /* |
2 | * Copyright (C) ST-Ericsson SA 2010 | |
3 | * | |
4 | * License Terms: GNU General Public License, version 2 | |
5 | * Author: Hanumath Prasad <hanumath.prasad@stericsson.com> for ST-Ericsson | |
6 | * Author: Rabin Vincent <rabin.vincent@stericsson.com> for ST-Ericsson | |
7 | */ | |
8 | ||
9 | #include <linux/module.h> | |
10 | #include <linux/interrupt.h> | |
11 | #include <linux/irq.h> | |
12 | #include <linux/slab.h> | |
13 | #include <linux/i2c.h> | |
14 | #include <linux/mfd/core.h> | |
c6eda6c5 | 15 | #include <linux/mfd/tc3589x.h> |
b4ecd326 RV |
16 | |
17 | /** | |
20406ebf SI |
18 | * tc3589x_reg_read() - read a single TC3589x register |
19 | * @tc3589x: Device to read from | |
b4ecd326 RV |
20 | * @reg: Register to read |
21 | */ | |
20406ebf | 22 | int tc3589x_reg_read(struct tc3589x *tc3589x, u8 reg) |
b4ecd326 RV |
23 | { |
24 | int ret; | |
25 | ||
20406ebf | 26 | ret = i2c_smbus_read_byte_data(tc3589x->i2c, reg); |
b4ecd326 | 27 | if (ret < 0) |
20406ebf | 28 | dev_err(tc3589x->dev, "failed to read reg %#x: %d\n", |
b4ecd326 RV |
29 | reg, ret); |
30 | ||
31 | return ret; | |
32 | } | |
20406ebf | 33 | EXPORT_SYMBOL_GPL(tc3589x_reg_read); |
b4ecd326 RV |
34 | |
35 | /** | |
20406ebf SI |
36 | * tc3589x_reg_read() - write a single TC3589x register |
37 | * @tc3589x: Device to write to | |
b4ecd326 RV |
38 | * @reg: Register to read |
39 | * @data: Value to write | |
40 | */ | |
20406ebf | 41 | int tc3589x_reg_write(struct tc3589x *tc3589x, u8 reg, u8 data) |
b4ecd326 RV |
42 | { |
43 | int ret; | |
44 | ||
20406ebf | 45 | ret = i2c_smbus_write_byte_data(tc3589x->i2c, reg, data); |
b4ecd326 | 46 | if (ret < 0) |
20406ebf | 47 | dev_err(tc3589x->dev, "failed to write reg %#x: %d\n", |
b4ecd326 RV |
48 | reg, ret); |
49 | ||
50 | return ret; | |
51 | } | |
20406ebf | 52 | EXPORT_SYMBOL_GPL(tc3589x_reg_write); |
b4ecd326 RV |
53 | |
54 | /** | |
20406ebf SI |
55 | * tc3589x_block_read() - read multiple TC3589x registers |
56 | * @tc3589x: Device to read from | |
b4ecd326 RV |
57 | * @reg: First register |
58 | * @length: Number of registers | |
59 | * @values: Buffer to write to | |
60 | */ | |
20406ebf | 61 | int tc3589x_block_read(struct tc3589x *tc3589x, u8 reg, u8 length, u8 *values) |
b4ecd326 RV |
62 | { |
63 | int ret; | |
64 | ||
20406ebf | 65 | ret = i2c_smbus_read_i2c_block_data(tc3589x->i2c, reg, length, values); |
b4ecd326 | 66 | if (ret < 0) |
20406ebf | 67 | dev_err(tc3589x->dev, "failed to read regs %#x: %d\n", |
b4ecd326 RV |
68 | reg, ret); |
69 | ||
70 | return ret; | |
71 | } | |
20406ebf | 72 | EXPORT_SYMBOL_GPL(tc3589x_block_read); |
b4ecd326 RV |
73 | |
74 | /** | |
20406ebf SI |
75 | * tc3589x_block_write() - write multiple TC3589x registers |
76 | * @tc3589x: Device to write to | |
b4ecd326 RV |
77 | * @reg: First register |
78 | * @length: Number of registers | |
79 | * @values: Values to write | |
80 | */ | |
20406ebf | 81 | int tc3589x_block_write(struct tc3589x *tc3589x, u8 reg, u8 length, |
b4ecd326 RV |
82 | const u8 *values) |
83 | { | |
84 | int ret; | |
85 | ||
20406ebf | 86 | ret = i2c_smbus_write_i2c_block_data(tc3589x->i2c, reg, length, |
b4ecd326 RV |
87 | values); |
88 | if (ret < 0) | |
20406ebf | 89 | dev_err(tc3589x->dev, "failed to write regs %#x: %d\n", |
b4ecd326 RV |
90 | reg, ret); |
91 | ||
92 | return ret; | |
93 | } | |
20406ebf | 94 | EXPORT_SYMBOL_GPL(tc3589x_block_write); |
b4ecd326 RV |
95 | |
96 | /** | |
20406ebf SI |
97 | * tc3589x_set_bits() - set the value of a bitfield in a TC3589x register |
98 | * @tc3589x: Device to write to | |
b4ecd326 RV |
99 | * @reg: Register to write |
100 | * @mask: Mask of bits to set | |
101 | * @values: Value to set | |
102 | */ | |
20406ebf | 103 | int tc3589x_set_bits(struct tc3589x *tc3589x, u8 reg, u8 mask, u8 val) |
b4ecd326 RV |
104 | { |
105 | int ret; | |
106 | ||
20406ebf | 107 | mutex_lock(&tc3589x->lock); |
b4ecd326 | 108 | |
20406ebf | 109 | ret = tc3589x_reg_read(tc3589x, reg); |
b4ecd326 RV |
110 | if (ret < 0) |
111 | goto out; | |
112 | ||
113 | ret &= ~mask; | |
114 | ret |= val; | |
115 | ||
20406ebf | 116 | ret = tc3589x_reg_write(tc3589x, reg, ret); |
b4ecd326 RV |
117 | |
118 | out: | |
20406ebf | 119 | mutex_unlock(&tc3589x->lock); |
b4ecd326 RV |
120 | return ret; |
121 | } | |
20406ebf | 122 | EXPORT_SYMBOL_GPL(tc3589x_set_bits); |
b4ecd326 RV |
123 | |
124 | static struct resource gpio_resources[] = { | |
125 | { | |
20406ebf SI |
126 | .start = TC3589x_INT_GPIIRQ, |
127 | .end = TC3589x_INT_GPIIRQ, | |
b4ecd326 RV |
128 | .flags = IORESOURCE_IRQ, |
129 | }, | |
130 | }; | |
131 | ||
20406ebf | 132 | static struct mfd_cell tc3589x_devs[] = { |
b4ecd326 | 133 | { |
20406ebf | 134 | .name = "tc3589x-gpio", |
b4ecd326 RV |
135 | .num_resources = ARRAY_SIZE(gpio_resources), |
136 | .resources = &gpio_resources[0], | |
137 | }, | |
138 | }; | |
139 | ||
20406ebf | 140 | static irqreturn_t tc3589x_irq(int irq, void *data) |
b4ecd326 | 141 | { |
20406ebf | 142 | struct tc3589x *tc3589x = data; |
b4ecd326 RV |
143 | int status; |
144 | ||
20406ebf | 145 | status = tc3589x_reg_read(tc3589x, TC3589x_IRQST); |
b4ecd326 RV |
146 | if (status < 0) |
147 | return IRQ_NONE; | |
148 | ||
149 | while (status) { | |
150 | int bit = __ffs(status); | |
151 | ||
20406ebf | 152 | handle_nested_irq(tc3589x->irq_base + bit); |
b4ecd326 RV |
153 | status &= ~(1 << bit); |
154 | } | |
155 | ||
156 | /* | |
157 | * A dummy read or write (to any register) appears to be necessary to | |
158 | * have the last interrupt clear (for example, GPIO IC write) take | |
159 | * effect. | |
160 | */ | |
20406ebf | 161 | tc3589x_reg_read(tc3589x, TC3589x_IRQST); |
b4ecd326 RV |
162 | |
163 | return IRQ_HANDLED; | |
164 | } | |
165 | ||
20406ebf | 166 | static void tc3589x_irq_dummy(unsigned int irq) |
b4ecd326 RV |
167 | { |
168 | /* No mask/unmask at this level */ | |
169 | } | |
170 | ||
20406ebf SI |
171 | static struct irq_chip tc3589x_irq_chip = { |
172 | .name = "tc3589x", | |
173 | .mask = tc3589x_irq_dummy, | |
174 | .unmask = tc3589x_irq_dummy, | |
b4ecd326 RV |
175 | }; |
176 | ||
20406ebf | 177 | static int tc3589x_irq_init(struct tc3589x *tc3589x) |
b4ecd326 | 178 | { |
20406ebf | 179 | int base = tc3589x->irq_base; |
b4ecd326 RV |
180 | int irq; |
181 | ||
20406ebf SI |
182 | for (irq = base; irq < base + TC3589x_NR_INTERNAL_IRQS; irq++) { |
183 | set_irq_chip_data(irq, tc3589x); | |
184 | set_irq_chip_and_handler(irq, &tc3589x_irq_chip, | |
b4ecd326 RV |
185 | handle_edge_irq); |
186 | set_irq_nested_thread(irq, 1); | |
187 | #ifdef CONFIG_ARM | |
188 | set_irq_flags(irq, IRQF_VALID); | |
189 | #else | |
190 | set_irq_noprobe(irq); | |
191 | #endif | |
192 | } | |
193 | ||
194 | return 0; | |
195 | } | |
196 | ||
20406ebf | 197 | static void tc3589x_irq_remove(struct tc3589x *tc3589x) |
b4ecd326 | 198 | { |
20406ebf | 199 | int base = tc3589x->irq_base; |
b4ecd326 RV |
200 | int irq; |
201 | ||
20406ebf | 202 | for (irq = base; irq < base + TC3589x_NR_INTERNAL_IRQS; irq++) { |
b4ecd326 RV |
203 | #ifdef CONFIG_ARM |
204 | set_irq_flags(irq, 0); | |
205 | #endif | |
206 | set_irq_chip_and_handler(irq, NULL, NULL); | |
207 | set_irq_chip_data(irq, NULL); | |
208 | } | |
209 | } | |
210 | ||
20406ebf | 211 | static int tc3589x_chip_init(struct tc3589x *tc3589x) |
b4ecd326 RV |
212 | { |
213 | int manf, ver, ret; | |
214 | ||
20406ebf | 215 | manf = tc3589x_reg_read(tc3589x, TC3589x_MANFCODE); |
b4ecd326 RV |
216 | if (manf < 0) |
217 | return manf; | |
218 | ||
20406ebf | 219 | ver = tc3589x_reg_read(tc3589x, TC3589x_VERSION); |
b4ecd326 RV |
220 | if (ver < 0) |
221 | return ver; | |
222 | ||
20406ebf SI |
223 | if (manf != TC3589x_MANFCODE_MAGIC) { |
224 | dev_err(tc3589x->dev, "unknown manufacturer: %#x\n", manf); | |
b4ecd326 RV |
225 | return -EINVAL; |
226 | } | |
227 | ||
20406ebf | 228 | dev_info(tc3589x->dev, "manufacturer: %#x, version: %#x\n", manf, ver); |
b4ecd326 RV |
229 | |
230 | /* Put everything except the IRQ module into reset */ | |
20406ebf SI |
231 | ret = tc3589x_reg_write(tc3589x, TC3589x_RSTCTRL, |
232 | TC3589x_RSTCTRL_TIMRST | |
233 | | TC3589x_RSTCTRL_ROTRST | |
234 | | TC3589x_RSTCTRL_KBDRST | |
235 | | TC3589x_RSTCTRL_GPIRST); | |
b4ecd326 RV |
236 | if (ret < 0) |
237 | return ret; | |
238 | ||
239 | /* Clear the reset interrupt. */ | |
20406ebf | 240 | return tc3589x_reg_write(tc3589x, TC3589x_RSTINTCLR, 0x1); |
b4ecd326 RV |
241 | } |
242 | ||
20406ebf | 243 | static int __devinit tc3589x_probe(struct i2c_client *i2c, |
b4ecd326 RV |
244 | const struct i2c_device_id *id) |
245 | { | |
20406ebf SI |
246 | struct tc3589x_platform_data *pdata = i2c->dev.platform_data; |
247 | struct tc3589x *tc3589x; | |
b4ecd326 RV |
248 | int ret; |
249 | ||
250 | if (!i2c_check_functionality(i2c->adapter, I2C_FUNC_SMBUS_BYTE_DATA | |
251 | | I2C_FUNC_SMBUS_I2C_BLOCK)) | |
252 | return -EIO; | |
253 | ||
20406ebf SI |
254 | tc3589x = kzalloc(sizeof(struct tc3589x), GFP_KERNEL); |
255 | if (!tc3589x) | |
b4ecd326 RV |
256 | return -ENOMEM; |
257 | ||
20406ebf | 258 | mutex_init(&tc3589x->lock); |
b4ecd326 | 259 | |
20406ebf SI |
260 | tc3589x->dev = &i2c->dev; |
261 | tc3589x->i2c = i2c; | |
262 | tc3589x->pdata = pdata; | |
263 | tc3589x->irq_base = pdata->irq_base; | |
264 | tc3589x->num_gpio = id->driver_data; | |
b4ecd326 | 265 | |
20406ebf | 266 | i2c_set_clientdata(i2c, tc3589x); |
b4ecd326 | 267 | |
20406ebf | 268 | ret = tc3589x_chip_init(tc3589x); |
b4ecd326 RV |
269 | if (ret) |
270 | goto out_free; | |
271 | ||
20406ebf | 272 | ret = tc3589x_irq_init(tc3589x); |
b4ecd326 RV |
273 | if (ret) |
274 | goto out_free; | |
275 | ||
20406ebf | 276 | ret = request_threaded_irq(tc3589x->i2c->irq, NULL, tc3589x_irq, |
b4ecd326 | 277 | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, |
20406ebf | 278 | "tc3589x", tc3589x); |
b4ecd326 | 279 | if (ret) { |
20406ebf | 280 | dev_err(tc3589x->dev, "failed to request IRQ: %d\n", ret); |
b4ecd326 RV |
281 | goto out_removeirq; |
282 | } | |
283 | ||
20406ebf SI |
284 | ret = mfd_add_devices(tc3589x->dev, -1, tc3589x_devs, |
285 | ARRAY_SIZE(tc3589x_devs), NULL, | |
286 | tc3589x->irq_base); | |
b4ecd326 | 287 | if (ret) { |
20406ebf | 288 | dev_err(tc3589x->dev, "failed to add children\n"); |
b4ecd326 RV |
289 | goto out_freeirq; |
290 | } | |
291 | ||
292 | return 0; | |
293 | ||
294 | out_freeirq: | |
20406ebf | 295 | free_irq(tc3589x->i2c->irq, tc3589x); |
b4ecd326 | 296 | out_removeirq: |
20406ebf | 297 | tc3589x_irq_remove(tc3589x); |
b4ecd326 | 298 | out_free: |
20406ebf | 299 | kfree(tc3589x); |
b4ecd326 RV |
300 | return ret; |
301 | } | |
302 | ||
20406ebf | 303 | static int __devexit tc3589x_remove(struct i2c_client *client) |
b4ecd326 | 304 | { |
20406ebf | 305 | struct tc3589x *tc3589x = i2c_get_clientdata(client); |
b4ecd326 | 306 | |
20406ebf | 307 | mfd_remove_devices(tc3589x->dev); |
b4ecd326 | 308 | |
20406ebf SI |
309 | free_irq(tc3589x->i2c->irq, tc3589x); |
310 | tc3589x_irq_remove(tc3589x); | |
b4ecd326 | 311 | |
20406ebf | 312 | kfree(tc3589x); |
b4ecd326 RV |
313 | |
314 | return 0; | |
315 | } | |
316 | ||
20406ebf SI |
317 | static const struct i2c_device_id tc3589x_id[] = { |
318 | { "tc3589x", 24 }, | |
b4ecd326 RV |
319 | { } |
320 | }; | |
20406ebf | 321 | MODULE_DEVICE_TABLE(i2c, tc3589x_id); |
b4ecd326 | 322 | |
20406ebf SI |
323 | static struct i2c_driver tc3589x_driver = { |
324 | .driver.name = "tc3589x", | |
b4ecd326 | 325 | .driver.owner = THIS_MODULE, |
20406ebf SI |
326 | .probe = tc3589x_probe, |
327 | .remove = __devexit_p(tc3589x_remove), | |
328 | .id_table = tc3589x_id, | |
b4ecd326 RV |
329 | }; |
330 | ||
20406ebf | 331 | static int __init tc3589x_init(void) |
b4ecd326 | 332 | { |
20406ebf | 333 | return i2c_add_driver(&tc3589x_driver); |
b4ecd326 | 334 | } |
20406ebf | 335 | subsys_initcall(tc3589x_init); |
b4ecd326 | 336 | |
20406ebf | 337 | static void __exit tc3589x_exit(void) |
b4ecd326 | 338 | { |
20406ebf | 339 | i2c_del_driver(&tc3589x_driver); |
b4ecd326 | 340 | } |
20406ebf | 341 | module_exit(tc3589x_exit); |
b4ecd326 RV |
342 | |
343 | MODULE_LICENSE("GPL v2"); | |
20406ebf | 344 | MODULE_DESCRIPTION("TC3589x MFD core driver"); |
b4ecd326 | 345 | MODULE_AUTHOR("Hanumath Prasad, Rabin Vincent"); |