blob: f629d6f4e3e94d6493b2bfed2db3e77a9841de30 [file] [log] [blame]
Haojian Zhuangbbd51b12010-01-06 17:04:18 -05001/*
Haojian Zhuang53dbab72010-01-08 06:01:24 -05002 * I2C driver for Marvell 88PM860x
Haojian Zhuangbbd51b12010-01-06 17:04:18 -05003 *
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>
Haojian Zhuang53dbab72010-01-08 06:01:24 -050015#include <linux/mfd/88pm860x.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090016#include <linux/slab.h>
Haojian Zhuangbbd51b12010-01-06 17:04:18 -050017
Haojian Zhuang53dbab72010-01-08 06:01:24 -050018static inline int pm860x_read_device(struct i2c_client *i2c,
Haojian Zhuangbbd51b12010-01-06 17:04:18 -050019 int reg, int bytes, void *dest)
20{
Haojian Zhuangbbd51b12010-01-06 17:04:18 -050021 unsigned char data;
22 int ret;
23
24 data = (unsigned char)reg;
25 ret = i2c_master_send(i2c, &data, 1);
26 if (ret < 0)
27 return ret;
28
29 ret = i2c_master_recv(i2c, dest, bytes);
30 if (ret < 0)
31 return ret;
32 return 0;
33}
34
Haojian Zhuang53dbab72010-01-08 06:01:24 -050035static inline int pm860x_write_device(struct i2c_client *i2c,
Haojian Zhuangbbd51b12010-01-06 17:04:18 -050036 int reg, int bytes, void *src)
37{
Haojian Zhuangbbd51b12010-01-06 17:04:18 -050038 unsigned char buf[bytes + 1];
39 int ret;
40
41 buf[0] = (unsigned char)reg;
42 memcpy(&buf[1], src, bytes);
43
44 ret = i2c_master_send(i2c, buf, bytes + 1);
45 if (ret < 0)
46 return ret;
47 return 0;
48}
49
Haojian Zhuang53dbab72010-01-08 06:01:24 -050050int pm860x_reg_read(struct i2c_client *i2c, int reg)
Haojian Zhuangbbd51b12010-01-06 17:04:18 -050051{
Haojian Zhuang53dbab72010-01-08 06:01:24 -050052 struct pm860x_chip *chip = i2c_get_clientdata(i2c);
Haojian Zhuangbbd51b12010-01-06 17:04:18 -050053 unsigned char data;
54 int ret;
55
56 mutex_lock(&chip->io_lock);
Haojian Zhuang53dbab72010-01-08 06:01:24 -050057 ret = pm860x_read_device(i2c, reg, 1, &data);
Haojian Zhuangbbd51b12010-01-06 17:04:18 -050058 mutex_unlock(&chip->io_lock);
59
60 if (ret < 0)
61 return ret;
62 else
63 return (int)data;
64}
Haojian Zhuang53dbab72010-01-08 06:01:24 -050065EXPORT_SYMBOL(pm860x_reg_read);
Haojian Zhuangbbd51b12010-01-06 17:04:18 -050066
Haojian Zhuang53dbab72010-01-08 06:01:24 -050067int pm860x_reg_write(struct i2c_client *i2c, int reg,
Haojian Zhuangbbd51b12010-01-06 17:04:18 -050068 unsigned char data)
69{
Haojian Zhuang53dbab72010-01-08 06:01:24 -050070 struct pm860x_chip *chip = i2c_get_clientdata(i2c);
Haojian Zhuangbbd51b12010-01-06 17:04:18 -050071 int ret;
72
73 mutex_lock(&chip->io_lock);
Haojian Zhuang53dbab72010-01-08 06:01:24 -050074 ret = pm860x_write_device(i2c, reg, 1, &data);
Haojian Zhuangbbd51b12010-01-06 17:04:18 -050075 mutex_unlock(&chip->io_lock);
76
77 return ret;
78}
Haojian Zhuang53dbab72010-01-08 06:01:24 -050079EXPORT_SYMBOL(pm860x_reg_write);
Haojian Zhuangbbd51b12010-01-06 17:04:18 -050080
Haojian Zhuang53dbab72010-01-08 06:01:24 -050081int pm860x_bulk_read(struct i2c_client *i2c, int reg,
Haojian Zhuangbbd51b12010-01-06 17:04:18 -050082 int count, unsigned char *buf)
83{
Haojian Zhuang53dbab72010-01-08 06:01:24 -050084 struct pm860x_chip *chip = i2c_get_clientdata(i2c);
Haojian Zhuangbbd51b12010-01-06 17:04:18 -050085 int ret;
86
87 mutex_lock(&chip->io_lock);
Haojian Zhuang53dbab72010-01-08 06:01:24 -050088 ret = pm860x_read_device(i2c, reg, count, buf);
Haojian Zhuangbbd51b12010-01-06 17:04:18 -050089 mutex_unlock(&chip->io_lock);
90
91 return ret;
92}
Haojian Zhuang53dbab72010-01-08 06:01:24 -050093EXPORT_SYMBOL(pm860x_bulk_read);
Haojian Zhuangbbd51b12010-01-06 17:04:18 -050094
Haojian Zhuang53dbab72010-01-08 06:01:24 -050095int pm860x_bulk_write(struct i2c_client *i2c, int reg,
Haojian Zhuangbbd51b12010-01-06 17:04:18 -050096 int count, unsigned char *buf)
97{
Haojian Zhuang53dbab72010-01-08 06:01:24 -050098 struct pm860x_chip *chip = i2c_get_clientdata(i2c);
Haojian Zhuangbbd51b12010-01-06 17:04:18 -050099 int ret;
100
101 mutex_lock(&chip->io_lock);
Haojian Zhuang53dbab72010-01-08 06:01:24 -0500102 ret = pm860x_write_device(i2c, reg, count, buf);
Haojian Zhuangbbd51b12010-01-06 17:04:18 -0500103 mutex_unlock(&chip->io_lock);
104
105 return ret;
106}
Haojian Zhuang53dbab72010-01-08 06:01:24 -0500107EXPORT_SYMBOL(pm860x_bulk_write);
Haojian Zhuangbbd51b12010-01-06 17:04:18 -0500108
Haojian Zhuang53dbab72010-01-08 06:01:24 -0500109int pm860x_set_bits(struct i2c_client *i2c, int reg,
Haojian Zhuangbbd51b12010-01-06 17:04:18 -0500110 unsigned char mask, unsigned char data)
111{
Haojian Zhuang53dbab72010-01-08 06:01:24 -0500112 struct pm860x_chip *chip = i2c_get_clientdata(i2c);
Haojian Zhuangbbd51b12010-01-06 17:04:18 -0500113 unsigned char value;
114 int ret;
115
116 mutex_lock(&chip->io_lock);
Haojian Zhuang53dbab72010-01-08 06:01:24 -0500117 ret = pm860x_read_device(i2c, reg, 1, &value);
Haojian Zhuangbbd51b12010-01-06 17:04:18 -0500118 if (ret < 0)
119 goto out;
120 value &= ~mask;
121 value |= data;
Haojian Zhuang53dbab72010-01-08 06:01:24 -0500122 ret = pm860x_write_device(i2c, reg, 1, &value);
Haojian Zhuangbbd51b12010-01-06 17:04:18 -0500123out:
124 mutex_unlock(&chip->io_lock);
125 return ret;
126}
Haojian Zhuang53dbab72010-01-08 06:01:24 -0500127EXPORT_SYMBOL(pm860x_set_bits);
Haojian Zhuangbbd51b12010-01-06 17:04:18 -0500128
Jett.Zhou5bdf7412011-11-11 15:38:26 +0800129static int read_device(struct i2c_client *i2c, int reg,
130 int bytes, void *dest)
131{
132 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX + 3];
133 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX + 2];
134 struct i2c_adapter *adap = i2c->adapter;
135 struct i2c_msg msg[2] = {{i2c->addr, 0, 1, msgbuf0},
136 {i2c->addr, I2C_M_RD, 0, msgbuf1},
137 };
138 int num = 1, ret = 0;
139
140 if (dest == NULL)
141 return -EINVAL;
142 msgbuf0[0] = (unsigned char)reg; /* command */
143 msg[1].len = bytes;
144
145 /* if data needs to read back, num should be 2 */
146 if (bytes > 0)
147 num = 2;
148 ret = adap->algo->master_xfer(adap, msg, num);
149 memcpy(dest, msgbuf1, bytes);
150 if (ret < 0)
151 return ret;
152 return 0;
153}
154
155static int write_device(struct i2c_client *i2c, int reg,
156 int bytes, void *src)
157{
158 unsigned char buf[bytes + 1];
159 struct i2c_adapter *adap = i2c->adapter;
160 struct i2c_msg msg;
161 int ret;
162
163 buf[0] = (unsigned char)reg;
164 memcpy(&buf[1], src, bytes);
165 msg.addr = i2c->addr;
166 msg.flags = 0;
167 msg.len = bytes + 1;
168 msg.buf = buf;
169
170 ret = adap->algo->master_xfer(adap, &msg, 1);
171 if (ret < 0)
172 return ret;
173 return 0;
174}
175
Haojian Zhuang09b03412011-03-07 23:43:16 +0800176int pm860x_page_reg_read(struct i2c_client *i2c, int reg)
177{
Haojian Zhuang09b03412011-03-07 23:43:16 +0800178 unsigned char zero = 0;
179 unsigned char data;
180 int ret;
181
Jett.Zhou5bdf7412011-11-11 15:38:26 +0800182 i2c_lock_adapter(i2c->adapter);
183 read_device(i2c, 0xFA, 0, &zero);
184 read_device(i2c, 0xFB, 0, &zero);
185 read_device(i2c, 0xFF, 0, &zero);
186 ret = read_device(i2c, reg, 1, &data);
Haojian Zhuang09b03412011-03-07 23:43:16 +0800187 if (ret >= 0)
188 ret = (int)data;
Jett.Zhou5bdf7412011-11-11 15:38:26 +0800189 read_device(i2c, 0xFE, 0, &zero);
190 read_device(i2c, 0xFC, 0, &zero);
191 i2c_unlock_adapter(i2c->adapter);
Haojian Zhuang09b03412011-03-07 23:43:16 +0800192 return ret;
193}
194EXPORT_SYMBOL(pm860x_page_reg_read);
195
196int pm860x_page_reg_write(struct i2c_client *i2c, int reg,
197 unsigned char data)
198{
Haojian Zhuang09b03412011-03-07 23:43:16 +0800199 unsigned char zero;
200 int ret;
201
Jett.Zhou5bdf7412011-11-11 15:38:26 +0800202 i2c_lock_adapter(i2c->adapter);
203 read_device(i2c, 0xFA, 0, &zero);
204 read_device(i2c, 0xFB, 0, &zero);
205 read_device(i2c, 0xFF, 0, &zero);
206 ret = write_device(i2c, reg, 1, &data);
207 read_device(i2c, 0xFE, 0, &zero);
208 read_device(i2c, 0xFC, 0, &zero);
209 i2c_unlock_adapter(i2c->adapter);
Haojian Zhuang09b03412011-03-07 23:43:16 +0800210 return ret;
211}
212EXPORT_SYMBOL(pm860x_page_reg_write);
213
214int pm860x_page_bulk_read(struct i2c_client *i2c, int reg,
215 int count, unsigned char *buf)
216{
Haojian Zhuang09b03412011-03-07 23:43:16 +0800217 unsigned char zero = 0;
218 int ret;
219
Jett.Zhou5bdf7412011-11-11 15:38:26 +0800220 i2c_lock_adapter(i2c->adapter);
221 read_device(i2c, 0xfa, 0, &zero);
222 read_device(i2c, 0xfb, 0, &zero);
223 read_device(i2c, 0xff, 0, &zero);
224 ret = read_device(i2c, reg, count, buf);
225 read_device(i2c, 0xFE, 0, &zero);
226 read_device(i2c, 0xFC, 0, &zero);
227 i2c_unlock_adapter(i2c->adapter);
Haojian Zhuang09b03412011-03-07 23:43:16 +0800228 return ret;
229}
230EXPORT_SYMBOL(pm860x_page_bulk_read);
231
232int pm860x_page_bulk_write(struct i2c_client *i2c, int reg,
233 int count, unsigned char *buf)
234{
Haojian Zhuang09b03412011-03-07 23:43:16 +0800235 unsigned char zero = 0;
236 int ret;
237
Jett.Zhou5bdf7412011-11-11 15:38:26 +0800238 i2c_lock_adapter(i2c->adapter);
239 read_device(i2c, 0xFA, 0, &zero);
240 read_device(i2c, 0xFB, 0, &zero);
241 read_device(i2c, 0xFF, 0, &zero);
242 ret = write_device(i2c, reg, count, buf);
243 read_device(i2c, 0xFE, 0, &zero);
244 read_device(i2c, 0xFC, 0, &zero);
245 i2c_unlock_adapter(i2c->adapter);
246 i2c_unlock_adapter(i2c->adapter);
Haojian Zhuang09b03412011-03-07 23:43:16 +0800247 return ret;
248}
249EXPORT_SYMBOL(pm860x_page_bulk_write);
250
251int pm860x_page_set_bits(struct i2c_client *i2c, int reg,
252 unsigned char mask, unsigned char data)
253{
Haojian Zhuang09b03412011-03-07 23:43:16 +0800254 unsigned char zero;
255 unsigned char value;
256 int ret;
257
Jett.Zhou5bdf7412011-11-11 15:38:26 +0800258 i2c_lock_adapter(i2c->adapter);
259 read_device(i2c, 0xFA, 0, &zero);
260 read_device(i2c, 0xFB, 0, &zero);
261 read_device(i2c, 0xFF, 0, &zero);
262 ret = read_device(i2c, reg, 1, &value);
Haojian Zhuang09b03412011-03-07 23:43:16 +0800263 if (ret < 0)
264 goto out;
265 value &= ~mask;
266 value |= data;
Jett.Zhou5bdf7412011-11-11 15:38:26 +0800267 ret = write_device(i2c, reg, 1, &value);
Haojian Zhuang09b03412011-03-07 23:43:16 +0800268out:
Jett.Zhou5bdf7412011-11-11 15:38:26 +0800269 read_device(i2c, 0xFE, 0, &zero);
270 read_device(i2c, 0xFC, 0, &zero);
271 i2c_unlock_adapter(i2c->adapter);
Haojian Zhuang09b03412011-03-07 23:43:16 +0800272 return ret;
273}
274EXPORT_SYMBOL(pm860x_page_set_bits);
Haojian Zhuangbbd51b12010-01-06 17:04:18 -0500275
276static const struct i2c_device_id pm860x_id_table[] = {
Haojian Zhuang53dbab72010-01-08 06:01:24 -0500277 { "88PM860x", 0 },
Haojian Zhuangbbd51b12010-01-06 17:04:18 -0500278 {}
279};
280MODULE_DEVICE_TABLE(i2c, pm860x_id_table);
281
Haojian Zhuang53dbab72010-01-08 06:01:24 -0500282static int verify_addr(struct i2c_client *i2c)
283{
284 unsigned short addr_8607[] = {0x30, 0x34};
285 unsigned short addr_8606[] = {0x10, 0x11};
286 int size, i;
287
288 if (i2c == NULL)
289 return 0;
290 size = ARRAY_SIZE(addr_8606);
291 for (i = 0; i < size; i++) {
292 if (i2c->addr == *(addr_8606 + i))
293 return CHIP_PM8606;
294 }
295 size = ARRAY_SIZE(addr_8607);
296 for (i = 0; i < size; i++) {
297 if (i2c->addr == *(addr_8607 + i))
298 return CHIP_PM8607;
299 }
300 return 0;
301}
302
Haojian Zhuangbbd51b12010-01-06 17:04:18 -0500303static int __devinit pm860x_probe(struct i2c_client *client,
304 const struct i2c_device_id *id)
305{
Haojian Zhuang53dbab72010-01-08 06:01:24 -0500306 struct pm860x_platform_data *pdata = client->dev.platform_data;
Haojian Zhuange8343dd2010-02-03 15:38:12 -0500307 struct pm860x_chip *chip;
Haojian Zhuangbbd51b12010-01-06 17:04:18 -0500308
Haojian Zhuange8343dd2010-02-03 15:38:12 -0500309 if (!pdata) {
Haojian Zhuang53dbab72010-01-08 06:01:24 -0500310 pr_info("No platform data in %s!\n", __func__);
311 return -EINVAL;
312 }
Haojian Zhuangbbd51b12010-01-06 17:04:18 -0500313
Haojian Zhuange8343dd2010-02-03 15:38:12 -0500314 chip = kzalloc(sizeof(struct pm860x_chip), GFP_KERNEL);
315 if (chip == NULL)
316 return -ENOMEM;
317
318 chip->id = verify_addr(client);
319 chip->client = client;
320 i2c_set_clientdata(client, chip);
321 chip->dev = &client->dev;
322 mutex_init(&chip->io_lock);
323 dev_set_drvdata(chip->dev, chip);
324
Haojian Zhuang53dbab72010-01-08 06:01:24 -0500325 /*
326 * Both client and companion client shares same platform driver.
327 * Driver distinguishes them by pdata->companion_addr.
328 * pdata->companion_addr is only assigned if companion chip exists.
329 * At the same time, the companion_addr shouldn't equal to client
330 * address.
331 */
Haojian Zhuange8343dd2010-02-03 15:38:12 -0500332 if (pdata->companion_addr && (pdata->companion_addr != client->addr)) {
333 chip->companion_addr = pdata->companion_addr;
334 chip->companion = i2c_new_dummy(chip->client->adapter,
335 chip->companion_addr);
Haojian Zhuang53dbab72010-01-08 06:01:24 -0500336 i2c_set_clientdata(chip->companion, chip);
Haojian Zhuang53dbab72010-01-08 06:01:24 -0500337 }
Haojian Zhuange8343dd2010-02-03 15:38:12 -0500338
339 pm860x_device_init(chip, pdata);
Haojian Zhuangbbd51b12010-01-06 17:04:18 -0500340 return 0;
Haojian Zhuangbbd51b12010-01-06 17:04:18 -0500341}
342
343static int __devexit pm860x_remove(struct i2c_client *client)
344{
Haojian Zhuang53dbab72010-01-08 06:01:24 -0500345 struct pm860x_chip *chip = i2c_get_clientdata(client);
Haojian Zhuangbbd51b12010-01-06 17:04:18 -0500346
Haojian Zhuang53dbab72010-01-08 06:01:24 -0500347 pm860x_device_exit(chip);
348 i2c_unregister_device(chip->companion);
Haojian Zhuangbbd51b12010-01-06 17:04:18 -0500349 kfree(chip);
350 return 0;
351}
352
353static struct i2c_driver pm860x_driver = {
354 .driver = {
355 .name = "88PM860x",
356 .owner = THIS_MODULE,
357 },
358 .probe = pm860x_probe,
359 .remove = __devexit_p(pm860x_remove),
360 .id_table = pm860x_id_table,
361};
362
363static int __init pm860x_i2c_init(void)
364{
365 int ret;
366 ret = i2c_add_driver(&pm860x_driver);
367 if (ret != 0)
368 pr_err("Failed to register 88PM860x I2C driver: %d\n", ret);
369 return ret;
370}
371subsys_initcall(pm860x_i2c_init);
372
373static void __exit pm860x_i2c_exit(void)
374{
375 i2c_del_driver(&pm860x_driver);
376}
377module_exit(pm860x_i2c_exit);
378
379MODULE_DESCRIPTION("I2C Driver for Marvell 88PM860x");
380MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
381MODULE_LICENSE("GPL");