xref: /openbmc/linux/drivers/misc/ad525x_dpot.c (revision b6dcefde)
1 /*
2  * ad525x_dpot: Driver for the Analog Devices AD525x digital potentiometers
3  * Copyright (c) 2009 Analog Devices, Inc.
4  * Author: Michael Hennerich <hennerich@blackfin.uclinux.org>
5  *
6  * DEVID		#Wipers		#Positions 	Resistor Options (kOhm)
7  * AD5258		1		64		1, 10, 50, 100
8  * AD5259		1		256		5, 10, 50, 100
9  * AD5251		2		64		1, 10, 50, 100
10  * AD5252		2		256		1, 10, 50, 100
11  * AD5255		3		512		25, 250
12  * AD5253		4		64		1, 10, 50, 100
13  * AD5254		4		256		1, 10, 50, 100
14  *
15  * See Documentation/misc-devices/ad525x_dpot.txt for more info.
16  *
17  * derived from ad5258.c
18  * Copyright (c) 2009 Cyber Switching, Inc.
19  * Author: Chris Verges <chrisv@cyberswitching.com>
20  *
21  * derived from ad5252.c
22  * Copyright (c) 2006 Michael Hennerich <hennerich@blackfin.uclinux.org>
23  *
24  * Licensed under the GPL-2 or later.
25  */
26 
27 #include <linux/module.h>
28 #include <linux/device.h>
29 #include <linux/kernel.h>
30 #include <linux/init.h>
31 #include <linux/slab.h>
32 #include <linux/i2c.h>
33 #include <linux/delay.h>
34 
35 #define DRIVER_NAME			"ad525x_dpot"
36 #define DRIVER_VERSION			"0.1"
37 
38 enum dpot_devid {
39 	AD5258_ID,
40 	AD5259_ID,
41 	AD5251_ID,
42 	AD5252_ID,
43 	AD5253_ID,
44 	AD5254_ID,
45 	AD5255_ID,
46 };
47 
48 #define AD5258_MAX_POSITION		64
49 #define AD5259_MAX_POSITION		256
50 #define AD5251_MAX_POSITION		64
51 #define AD5252_MAX_POSITION		256
52 #define AD5253_MAX_POSITION		64
53 #define AD5254_MAX_POSITION		256
54 #define AD5255_MAX_POSITION		512
55 
56 #define AD525X_RDAC0		0
57 #define AD525X_RDAC1		1
58 #define AD525X_RDAC2		2
59 #define AD525X_RDAC3		3
60 
61 #define AD525X_REG_TOL		0x18
62 #define AD525X_TOL_RDAC0	(AD525X_REG_TOL | AD525X_RDAC0)
63 #define AD525X_TOL_RDAC1	(AD525X_REG_TOL | AD525X_RDAC1)
64 #define AD525X_TOL_RDAC2	(AD525X_REG_TOL | AD525X_RDAC2)
65 #define AD525X_TOL_RDAC3	(AD525X_REG_TOL | AD525X_RDAC3)
66 
67 /* RDAC-to-EEPROM Interface Commands */
68 #define AD525X_I2C_RDAC		(0x00 << 5)
69 #define AD525X_I2C_EEPROM	(0x01 << 5)
70 #define AD525X_I2C_CMD		(0x80)
71 
72 #define AD525X_DEC_ALL_6DB	(AD525X_I2C_CMD | (0x4 << 3))
73 #define AD525X_INC_ALL_6DB	(AD525X_I2C_CMD | (0x9 << 3))
74 #define AD525X_DEC_ALL		(AD525X_I2C_CMD | (0x6 << 3))
75 #define AD525X_INC_ALL		(AD525X_I2C_CMD | (0xB << 3))
76 
77 static s32 ad525x_read(struct i2c_client *client, u8 reg);
78 static s32 ad525x_write(struct i2c_client *client, u8 reg, u8 value);
79 
80 /*
81  * Client data (each client gets its own)
82  */
83 
84 struct dpot_data {
85 	struct mutex update_lock;
86 	unsigned rdac_mask;
87 	unsigned max_pos;
88 	unsigned devid;
89 };
90 
91 /* sysfs functions */
92 
93 static ssize_t sysfs_show_reg(struct device *dev,
94 			      struct device_attribute *attr, char *buf, u32 reg)
95 {
96 	struct i2c_client *client = to_i2c_client(dev);
97 	struct dpot_data *data = i2c_get_clientdata(client);
98 	s32 value;
99 
100 	mutex_lock(&data->update_lock);
101 	value = ad525x_read(client, reg);
102 	mutex_unlock(&data->update_lock);
103 
104 	if (value < 0)
105 		return -EINVAL;
106 	/*
107 	 * Let someone else deal with converting this ...
108 	 * the tolerance is a two-byte value where the MSB
109 	 * is a sign + integer value, and the LSB is a
110 	 * decimal value.  See page 18 of the AD5258
111 	 * datasheet (Rev. A) for more details.
112 	 */
113 
114 	if (reg & AD525X_REG_TOL)
115 		return sprintf(buf, "0x%04x\n", value & 0xFFFF);
116 	else
117 		return sprintf(buf, "%u\n", value & data->rdac_mask);
118 }
119 
120 static ssize_t sysfs_set_reg(struct device *dev,
121 			     struct device_attribute *attr,
122 			     const char *buf, size_t count, u32 reg)
123 {
124 	struct i2c_client *client = to_i2c_client(dev);
125 	struct dpot_data *data = i2c_get_clientdata(client);
126 	unsigned long value;
127 	int err;
128 
129 	err = strict_strtoul(buf, 10, &value);
130 	if (err)
131 		return err;
132 
133 	if (value > data->rdac_mask)
134 		value = data->rdac_mask;
135 
136 	mutex_lock(&data->update_lock);
137 	ad525x_write(client, reg, value);
138 	if (reg & AD525X_I2C_EEPROM)
139 		msleep(26);	/* Sleep while the EEPROM updates */
140 	mutex_unlock(&data->update_lock);
141 
142 	return count;
143 }
144 
145 static ssize_t sysfs_do_cmd(struct device *dev,
146 			    struct device_attribute *attr,
147 			    const char *buf, size_t count, u32 reg)
148 {
149 	struct i2c_client *client = to_i2c_client(dev);
150 	struct dpot_data *data = i2c_get_clientdata(client);
151 
152 	mutex_lock(&data->update_lock);
153 	ad525x_write(client, reg, 0);
154 	mutex_unlock(&data->update_lock);
155 
156 	return count;
157 }
158 
159 /* ------------------------------------------------------------------------- */
160 
161 static ssize_t show_rdac0(struct device *dev,
162 			  struct device_attribute *attr, char *buf)
163 {
164 	return sysfs_show_reg(dev, attr, buf, AD525X_I2C_RDAC | AD525X_RDAC0);
165 }
166 
167 static ssize_t set_rdac0(struct device *dev,
168 			 struct device_attribute *attr,
169 			 const char *buf, size_t count)
170 {
171 	return sysfs_set_reg(dev, attr, buf, count,
172 			     AD525X_I2C_RDAC | AD525X_RDAC0);
173 }
174 
175 static DEVICE_ATTR(rdac0, S_IWUSR | S_IRUGO, show_rdac0, set_rdac0);
176 
177 static ssize_t show_eeprom0(struct device *dev,
178 			    struct device_attribute *attr, char *buf)
179 {
180 	return sysfs_show_reg(dev, attr, buf, AD525X_I2C_EEPROM | AD525X_RDAC0);
181 }
182 
183 static ssize_t set_eeprom0(struct device *dev,
184 			   struct device_attribute *attr,
185 			   const char *buf, size_t count)
186 {
187 	return sysfs_set_reg(dev, attr, buf, count,
188 			     AD525X_I2C_EEPROM | AD525X_RDAC0);
189 }
190 
191 static DEVICE_ATTR(eeprom0, S_IWUSR | S_IRUGO, show_eeprom0, set_eeprom0);
192 
193 static ssize_t show_tolerance0(struct device *dev,
194 			       struct device_attribute *attr, char *buf)
195 {
196 	return sysfs_show_reg(dev, attr, buf,
197 			      AD525X_I2C_EEPROM | AD525X_TOL_RDAC0);
198 }
199 
200 static DEVICE_ATTR(tolerance0, S_IRUGO, show_tolerance0, NULL);
201 
202 /* ------------------------------------------------------------------------- */
203 
204 static ssize_t show_rdac1(struct device *dev,
205 			  struct device_attribute *attr, char *buf)
206 {
207 	return sysfs_show_reg(dev, attr, buf, AD525X_I2C_RDAC | AD525X_RDAC1);
208 }
209 
210 static ssize_t set_rdac1(struct device *dev,
211 			 struct device_attribute *attr,
212 			 const char *buf, size_t count)
213 {
214 	return sysfs_set_reg(dev, attr, buf, count,
215 			     AD525X_I2C_RDAC | AD525X_RDAC1);
216 }
217 
218 static DEVICE_ATTR(rdac1, S_IWUSR | S_IRUGO, show_rdac1, set_rdac1);
219 
220 static ssize_t show_eeprom1(struct device *dev,
221 			    struct device_attribute *attr, char *buf)
222 {
223 	return sysfs_show_reg(dev, attr, buf, AD525X_I2C_EEPROM | AD525X_RDAC1);
224 }
225 
226 static ssize_t set_eeprom1(struct device *dev,
227 			   struct device_attribute *attr,
228 			   const char *buf, size_t count)
229 {
230 	return sysfs_set_reg(dev, attr, buf, count,
231 			     AD525X_I2C_EEPROM | AD525X_RDAC1);
232 }
233 
234 static DEVICE_ATTR(eeprom1, S_IWUSR | S_IRUGO, show_eeprom1, set_eeprom1);
235 
236 static ssize_t show_tolerance1(struct device *dev,
237 			       struct device_attribute *attr, char *buf)
238 {
239 	return sysfs_show_reg(dev, attr, buf,
240 			      AD525X_I2C_EEPROM | AD525X_TOL_RDAC1);
241 }
242 
243 static DEVICE_ATTR(tolerance1, S_IRUGO, show_tolerance1, NULL);
244 
245 /* ------------------------------------------------------------------------- */
246 
247 static ssize_t show_rdac2(struct device *dev,
248 			  struct device_attribute *attr, char *buf)
249 {
250 	return sysfs_show_reg(dev, attr, buf, AD525X_I2C_RDAC | AD525X_RDAC2);
251 }
252 
253 static ssize_t set_rdac2(struct device *dev,
254 			 struct device_attribute *attr,
255 			 const char *buf, size_t count)
256 {
257 	return sysfs_set_reg(dev, attr, buf, count,
258 			     AD525X_I2C_RDAC | AD525X_RDAC2);
259 }
260 
261 static DEVICE_ATTR(rdac2, S_IWUSR | S_IRUGO, show_rdac2, set_rdac2);
262 
263 static ssize_t show_eeprom2(struct device *dev,
264 			    struct device_attribute *attr, char *buf)
265 {
266 	return sysfs_show_reg(dev, attr, buf, AD525X_I2C_EEPROM | AD525X_RDAC2);
267 }
268 
269 static ssize_t set_eeprom2(struct device *dev,
270 			   struct device_attribute *attr,
271 			   const char *buf, size_t count)
272 {
273 	return sysfs_set_reg(dev, attr, buf, count,
274 			     AD525X_I2C_EEPROM | AD525X_RDAC2);
275 }
276 
277 static DEVICE_ATTR(eeprom2, S_IWUSR | S_IRUGO, show_eeprom2, set_eeprom2);
278 
279 static ssize_t show_tolerance2(struct device *dev,
280 			       struct device_attribute *attr, char *buf)
281 {
282 	return sysfs_show_reg(dev, attr, buf,
283 			      AD525X_I2C_EEPROM | AD525X_TOL_RDAC2);
284 }
285 
286 static DEVICE_ATTR(tolerance2, S_IRUGO, show_tolerance2, NULL);
287 
288 /* ------------------------------------------------------------------------- */
289 
290 static ssize_t show_rdac3(struct device *dev,
291 			  struct device_attribute *attr, char *buf)
292 {
293 	return sysfs_show_reg(dev, attr, buf, AD525X_I2C_RDAC | AD525X_RDAC3);
294 }
295 
296 static ssize_t set_rdac3(struct device *dev,
297 			 struct device_attribute *attr,
298 			 const char *buf, size_t count)
299 {
300 	return sysfs_set_reg(dev, attr, buf, count,
301 			     AD525X_I2C_RDAC | AD525X_RDAC3);
302 }
303 
304 static DEVICE_ATTR(rdac3, S_IWUSR | S_IRUGO, show_rdac3, set_rdac3);
305 
306 static ssize_t show_eeprom3(struct device *dev,
307 			    struct device_attribute *attr, char *buf)
308 {
309 	return sysfs_show_reg(dev, attr, buf, AD525X_I2C_EEPROM | AD525X_RDAC3);
310 }
311 
312 static ssize_t set_eeprom3(struct device *dev,
313 			   struct device_attribute *attr,
314 			   const char *buf, size_t count)
315 {
316 	return sysfs_set_reg(dev, attr, buf, count,
317 			     AD525X_I2C_EEPROM | AD525X_RDAC3);
318 }
319 
320 static DEVICE_ATTR(eeprom3, S_IWUSR | S_IRUGO, show_eeprom3, set_eeprom3);
321 
322 static ssize_t show_tolerance3(struct device *dev,
323 			       struct device_attribute *attr, char *buf)
324 {
325 	return sysfs_show_reg(dev, attr, buf,
326 			      AD525X_I2C_EEPROM | AD525X_TOL_RDAC3);
327 }
328 
329 static DEVICE_ATTR(tolerance3, S_IRUGO, show_tolerance3, NULL);
330 
331 static struct attribute *ad525x_attributes_wipers[4][4] = {
332 	{
333 		&dev_attr_rdac0.attr,
334 		&dev_attr_eeprom0.attr,
335 		&dev_attr_tolerance0.attr,
336 		NULL
337 	}, {
338 		&dev_attr_rdac1.attr,
339 		&dev_attr_eeprom1.attr,
340 		&dev_attr_tolerance1.attr,
341 		NULL
342 	}, {
343 		&dev_attr_rdac2.attr,
344 		&dev_attr_eeprom2.attr,
345 		&dev_attr_tolerance2.attr,
346 		NULL
347 	}, {
348 		&dev_attr_rdac3.attr,
349 		&dev_attr_eeprom3.attr,
350 		&dev_attr_tolerance3.attr,
351 		NULL
352 	}
353 };
354 
355 static const struct attribute_group ad525x_group_wipers[] = {
356 	{.attrs = ad525x_attributes_wipers[AD525X_RDAC0]},
357 	{.attrs = ad525x_attributes_wipers[AD525X_RDAC1]},
358 	{.attrs = ad525x_attributes_wipers[AD525X_RDAC2]},
359 	{.attrs = ad525x_attributes_wipers[AD525X_RDAC3]},
360 };
361 
362 /* ------------------------------------------------------------------------- */
363 
364 static ssize_t set_inc_all(struct device *dev,
365 			   struct device_attribute *attr,
366 			   const char *buf, size_t count)
367 {
368 	return sysfs_do_cmd(dev, attr, buf, count, AD525X_INC_ALL);
369 }
370 
371 static DEVICE_ATTR(inc_all, S_IWUSR, NULL, set_inc_all);
372 
373 static ssize_t set_dec_all(struct device *dev,
374 			   struct device_attribute *attr,
375 			   const char *buf, size_t count)
376 {
377 	return sysfs_do_cmd(dev, attr, buf, count, AD525X_DEC_ALL);
378 }
379 
380 static DEVICE_ATTR(dec_all, S_IWUSR, NULL, set_dec_all);
381 
382 static ssize_t set_inc_all_6db(struct device *dev,
383 			       struct device_attribute *attr,
384 			       const char *buf, size_t count)
385 {
386 	return sysfs_do_cmd(dev, attr, buf, count, AD525X_INC_ALL_6DB);
387 }
388 
389 static DEVICE_ATTR(inc_all_6db, S_IWUSR, NULL, set_inc_all_6db);
390 
391 static ssize_t set_dec_all_6db(struct device *dev,
392 			       struct device_attribute *attr,
393 			       const char *buf, size_t count)
394 {
395 	return sysfs_do_cmd(dev, attr, buf, count, AD525X_DEC_ALL_6DB);
396 }
397 
398 static DEVICE_ATTR(dec_all_6db, S_IWUSR, NULL, set_dec_all_6db);
399 
400 static struct attribute *ad525x_attributes_commands[] = {
401 	&dev_attr_inc_all.attr,
402 	&dev_attr_dec_all.attr,
403 	&dev_attr_inc_all_6db.attr,
404 	&dev_attr_dec_all_6db.attr,
405 	NULL
406 };
407 
408 static const struct attribute_group ad525x_group_commands = {
409 	.attrs = ad525x_attributes_commands,
410 };
411 
412 /* ------------------------------------------------------------------------- */
413 
414 /* i2c device functions */
415 
416 /**
417  * ad525x_read - return the value contained in the specified register
418  * on the AD5258 device.
419  * @client: value returned from i2c_new_device()
420  * @reg: the register to read
421  *
422  * If the tolerance register is specified, 2 bytes are returned.
423  * Otherwise, 1 byte is returned.  A negative value indicates an error
424  * occurred while reading the register.
425  */
426 static s32 ad525x_read(struct i2c_client *client, u8 reg)
427 {
428 	struct dpot_data *data = i2c_get_clientdata(client);
429 
430 	if ((reg & AD525X_REG_TOL) || (data->max_pos > 256))
431 		return i2c_smbus_read_word_data(client, (reg & 0xF8) |
432 						((reg & 0x7) << 1));
433 	else
434 		return i2c_smbus_read_byte_data(client, reg);
435 }
436 
437 /**
438  * ad525x_write - store the given value in the specified register on
439  * the AD5258 device.
440  * @client: value returned from i2c_new_device()
441  * @reg: the register to write
442  * @value: the byte to store in the register
443  *
444  * For certain instructions that do not require a data byte, "NULL"
445  * should be specified for the "value" parameter.  These instructions
446  * include NOP, RESTORE_FROM_EEPROM, and STORE_TO_EEPROM.
447  *
448  * A negative return value indicates an error occurred while reading
449  * the register.
450  */
451 static s32 ad525x_write(struct i2c_client *client, u8 reg, u8 value)
452 {
453 	struct dpot_data *data = i2c_get_clientdata(client);
454 
455 	/* Only write the instruction byte for certain commands */
456 	if (reg & AD525X_I2C_CMD)
457 		return i2c_smbus_write_byte(client, reg);
458 
459 	if (data->max_pos > 256)
460 		return i2c_smbus_write_word_data(client, (reg & 0xF8) |
461 						((reg & 0x7) << 1), value);
462 	else
463 		/* All other registers require instruction + data bytes */
464 		return i2c_smbus_write_byte_data(client, reg, value);
465 }
466 
467 static int ad525x_probe(struct i2c_client *client,
468 			const struct i2c_device_id *id)
469 {
470 	struct device *dev = &client->dev;
471 	struct dpot_data *data;
472 	int err = 0;
473 
474 	dev_dbg(dev, "%s\n", __func__);
475 
476 	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE)) {
477 		dev_err(dev, "missing I2C functionality for this driver\n");
478 		goto exit;
479 	}
480 
481 	data = kzalloc(sizeof(struct dpot_data), GFP_KERNEL);
482 	if (!data) {
483 		err = -ENOMEM;
484 		goto exit;
485 	}
486 
487 	i2c_set_clientdata(client, data);
488 	mutex_init(&data->update_lock);
489 
490 	switch (id->driver_data) {
491 	case AD5258_ID:
492 		data->max_pos = AD5258_MAX_POSITION;
493 		err = sysfs_create_group(&dev->kobj,
494 				       &ad525x_group_wipers[AD525X_RDAC0]);
495 		break;
496 	case AD5259_ID:
497 		data->max_pos = AD5259_MAX_POSITION;
498 		err = sysfs_create_group(&dev->kobj,
499 				       &ad525x_group_wipers[AD525X_RDAC0]);
500 		break;
501 	case AD5251_ID:
502 		data->max_pos = AD5251_MAX_POSITION;
503 		err = sysfs_create_group(&dev->kobj,
504 				       &ad525x_group_wipers[AD525X_RDAC1]);
505 		err |= sysfs_create_group(&dev->kobj,
506 				       &ad525x_group_wipers[AD525X_RDAC3]);
507 		err |= sysfs_create_group(&dev->kobj, &ad525x_group_commands);
508 		break;
509 	case AD5252_ID:
510 		data->max_pos = AD5252_MAX_POSITION;
511 		err = sysfs_create_group(&dev->kobj,
512 				       &ad525x_group_wipers[AD525X_RDAC1]);
513 		err |= sysfs_create_group(&dev->kobj,
514 				       &ad525x_group_wipers[AD525X_RDAC3]);
515 		err |= sysfs_create_group(&dev->kobj, &ad525x_group_commands);
516 		break;
517 	case AD5253_ID:
518 		data->max_pos = AD5253_MAX_POSITION;
519 		err = sysfs_create_group(&dev->kobj,
520 				       &ad525x_group_wipers[AD525X_RDAC0]);
521 		err |= sysfs_create_group(&dev->kobj,
522 				       &ad525x_group_wipers[AD525X_RDAC1]);
523 		err |= sysfs_create_group(&dev->kobj,
524 				       &ad525x_group_wipers[AD525X_RDAC2]);
525 		err |= sysfs_create_group(&dev->kobj,
526 				       &ad525x_group_wipers[AD525X_RDAC3]);
527 		err |= sysfs_create_group(&dev->kobj, &ad525x_group_commands);
528 		break;
529 	case AD5254_ID:
530 		data->max_pos = AD5254_MAX_POSITION;
531 		err = sysfs_create_group(&dev->kobj,
532 				       &ad525x_group_wipers[AD525X_RDAC0]);
533 		err |= sysfs_create_group(&dev->kobj,
534 				       &ad525x_group_wipers[AD525X_RDAC1]);
535 		err |= sysfs_create_group(&dev->kobj,
536 				       &ad525x_group_wipers[AD525X_RDAC2]);
537 		err |= sysfs_create_group(&dev->kobj,
538 				       &ad525x_group_wipers[AD525X_RDAC3]);
539 		err |= sysfs_create_group(&dev->kobj, &ad525x_group_commands);
540 		break;
541 	case AD5255_ID:
542 		data->max_pos = AD5255_MAX_POSITION;
543 		err = sysfs_create_group(&dev->kobj,
544 				       &ad525x_group_wipers[AD525X_RDAC0]);
545 		err |= sysfs_create_group(&dev->kobj,
546 				       &ad525x_group_wipers[AD525X_RDAC1]);
547 		err |= sysfs_create_group(&dev->kobj,
548 				       &ad525x_group_wipers[AD525X_RDAC2]);
549 		err |= sysfs_create_group(&dev->kobj, &ad525x_group_commands);
550 		break;
551 	default:
552 		err = -ENODEV;
553 		goto exit_free;
554 	}
555 
556 	if (err) {
557 		dev_err(dev, "failed to register sysfs hooks\n");
558 		goto exit_free;
559 	}
560 
561 	data->devid = id->driver_data;
562 	data->rdac_mask = data->max_pos - 1;
563 
564 	dev_info(dev, "%s %d-Position Digital Potentiometer registered\n",
565 		 id->name, data->max_pos);
566 
567 	return 0;
568 
569 exit_free:
570 	kfree(data);
571 	i2c_set_clientdata(client, NULL);
572 exit:
573 	dev_err(dev, "failed to create client\n");
574 	return err;
575 }
576 
577 static int __devexit ad525x_remove(struct i2c_client *client)
578 {
579 	struct dpot_data *data = i2c_get_clientdata(client);
580 	struct device *dev = &client->dev;
581 
582 	switch (data->devid) {
583 	case AD5258_ID:
584 	case AD5259_ID:
585 		sysfs_remove_group(&dev->kobj,
586 				   &ad525x_group_wipers[AD525X_RDAC0]);
587 		break;
588 	case AD5251_ID:
589 	case AD5252_ID:
590 		sysfs_remove_group(&dev->kobj,
591 				   &ad525x_group_wipers[AD525X_RDAC1]);
592 		sysfs_remove_group(&dev->kobj,
593 				   &ad525x_group_wipers[AD525X_RDAC3]);
594 		sysfs_remove_group(&dev->kobj, &ad525x_group_commands);
595 		break;
596 	case AD5253_ID:
597 	case AD5254_ID:
598 		sysfs_remove_group(&dev->kobj,
599 				   &ad525x_group_wipers[AD525X_RDAC0]);
600 		sysfs_remove_group(&dev->kobj,
601 				   &ad525x_group_wipers[AD525X_RDAC1]);
602 		sysfs_remove_group(&dev->kobj,
603 				   &ad525x_group_wipers[AD525X_RDAC2]);
604 		sysfs_remove_group(&dev->kobj,
605 				   &ad525x_group_wipers[AD525X_RDAC3]);
606 		sysfs_remove_group(&dev->kobj, &ad525x_group_commands);
607 		break;
608 	case AD5255_ID:
609 		sysfs_remove_group(&dev->kobj,
610 				   &ad525x_group_wipers[AD525X_RDAC0]);
611 		sysfs_remove_group(&dev->kobj,
612 				   &ad525x_group_wipers[AD525X_RDAC1]);
613 		sysfs_remove_group(&dev->kobj,
614 				   &ad525x_group_wipers[AD525X_RDAC2]);
615 		sysfs_remove_group(&dev->kobj, &ad525x_group_commands);
616 		break;
617 	}
618 
619 	i2c_set_clientdata(client, NULL);
620 	kfree(data);
621 
622 	return 0;
623 }
624 
625 static const struct i2c_device_id ad525x_idtable[] = {
626 	{"ad5258", AD5258_ID},
627 	{"ad5259", AD5259_ID},
628 	{"ad5251", AD5251_ID},
629 	{"ad5252", AD5252_ID},
630 	{"ad5253", AD5253_ID},
631 	{"ad5254", AD5254_ID},
632 	{"ad5255", AD5255_ID},
633 	{}
634 };
635 
636 MODULE_DEVICE_TABLE(i2c, ad525x_idtable);
637 
638 static struct i2c_driver ad525x_driver = {
639 	.driver = {
640 		   .owner = THIS_MODULE,
641 		   .name = DRIVER_NAME,
642 		   },
643 	.id_table = ad525x_idtable,
644 	.probe = ad525x_probe,
645 	.remove = __devexit_p(ad525x_remove),
646 };
647 
648 static int __init ad525x_init(void)
649 {
650 	return i2c_add_driver(&ad525x_driver);
651 }
652 
653 module_init(ad525x_init);
654 
655 static void __exit ad525x_exit(void)
656 {
657 	i2c_del_driver(&ad525x_driver);
658 }
659 
660 module_exit(ad525x_exit);
661 
662 MODULE_AUTHOR("Chris Verges <chrisv@cyberswitching.com>, "
663 	      "Michael Hennerich <hennerich@blackfin.uclinux.org>, ");
664 MODULE_DESCRIPTION("AD5258/9 digital potentiometer driver");
665 MODULE_LICENSE("GPL");
666 MODULE_VERSION(DRIVER_VERSION);
667