[net-next-2.6.git] / drivers / misc / ad525x_dpot-i2c.c

/*
 * Driver for the Analog Devices digital potentiometers (I2C bus)
 *
 * Copyright (C) 2010 Michael Hennerich, Analog Devices Inc.
 *
 * Licensed under the GPL-2 or later.
 */

#include <linux/i2c.h>
#include <linux/module.h>

#include "ad525x_dpot.h"

/* ------------------------------------------------------------------------- */
/* I2C bus functions */
static int write_d8(void *client, u8 val)
{
	return i2c_smbus_write_byte(client, val);
}

static int write_r8d8(void *client, u8 reg, u8 val)
{
	return i2c_smbus_write_byte_data(client, reg, val);
}

static int write_r8d16(void *client, u8 reg, u16 val)
{
	return i2c_smbus_write_word_data(client, reg, val);
}

static int read_d8(void *client)
{
	return i2c_smbus_read_byte(client);
}

static int read_r8d8(void *client, u8 reg)
{
	return i2c_smbus_read_byte_data(client, reg);
}

static int read_r8d16(void *client, u8 reg)
{
	return i2c_smbus_read_word_data(client, reg);
}

static const struct ad_dpot_bus_ops bops = {
	.read_d8	= read_d8,
	.read_r8d8	= read_r8d8,
	.read_r8d16	= read_r8d16,
	.write_d8	= write_d8,
	.write_r8d8	= write_r8d8,
	.write_r8d16	= write_r8d16,
};

static int __devinit ad_dpot_i2c_probe(struct i2c_client *client,
				      const struct i2c_device_id *id)
{
	struct ad_dpot_bus_data bdata = {
		.client = client,
		.bops = &bops,
	};

	struct ad_dpot_id dpot_id = {
		.name = (char *) &id->name,
		.devid = id->driver_data,
	};

	if (!i2c_check_functionality(client->adapter,
				     I2C_FUNC_SMBUS_WORD_DATA)) {
		dev_err(&client->dev, "SMBUS Word Data not Supported\n");
		return -EIO;
	}

	return ad_dpot_probe(&client->dev, &bdata, &dpot_id);
}

static int __devexit ad_dpot_i2c_remove(struct i2c_client *client)
{
	return ad_dpot_remove(&client->dev);
}

static const struct i2c_device_id ad_dpot_id[] = {
	{"ad5258", AD5258_ID},
	{"ad5259", AD5259_ID},
	{"ad5251", AD5251_ID},
	{"ad5252", AD5252_ID},
	{"ad5253", AD5253_ID},
	{"ad5254", AD5254_ID},
	{"ad5255", AD5255_ID},
	{"ad5241", AD5241_ID},
	{"ad5242", AD5242_ID},
	{"ad5243", AD5243_ID},
	{"ad5245", AD5245_ID},
	{"ad5246", AD5246_ID},
	{"ad5247", AD5247_ID},
	{"ad5248", AD5248_ID},
	{"ad5280", AD5280_ID},
	{"ad5282", AD5282_ID},
	{"adn2860", ADN2860_ID},
	{"ad5273", AD5273_ID},
	{"ad5171", AD5171_ID},
	{"ad5170", AD5170_ID},
	{"ad5172", AD5172_ID},
	{"ad5173", AD5173_ID},
	{"ad5272", AD5272_ID},
	{"ad5274", AD5274_ID},
	{}
};
MODULE_DEVICE_TABLE(i2c, ad_dpot_id);

static struct i2c_driver ad_dpot_i2c_driver = {
	.driver = {
		.name	= "ad_dpot",
		.owner	= THIS_MODULE,
	},
	.probe		= ad_dpot_i2c_probe,
	.remove		= __devexit_p(ad_dpot_i2c_remove),
	.id_table	= ad_dpot_id,
};

static int __init ad_dpot_i2c_init(void)
{
	return i2c_add_driver(&ad_dpot_i2c_driver);
}
module_init(ad_dpot_i2c_init);

static void __exit ad_dpot_i2c_exit(void)
{
	i2c_del_driver(&ad_dpot_i2c_driver);
}
module_exit(ad_dpot_i2c_exit);

MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
MODULE_DESCRIPTION("digital potentiometer I2C bus driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("i2c:ad_dpot");
Commit	Line	Data
6c536e4c MH	1	/*
	2	* Driver for the Analog Devices digital potentiometers (I2C bus)
	3	*
	4	* Copyright (C) 2010 Michael Hennerich, Analog Devices Inc.
	5	*
	6	* Licensed under the GPL-2 or later.
	7	*/
	8
	9	#include <linux/i2c.h>
	10	#include <linux/module.h>
	11
	12	#include "ad525x_dpot.h"
	13
	14	/* ------------------------------------------------------------------------- */
	15	/* I2C bus functions */
	16	static int write_d8(void *client, u8 val)
	17	{
	18	return i2c_smbus_write_byte(client, val);
	19	}
	20
	21	static int write_r8d8(void *client, u8 reg, u8 val)
	22	{
	23	return i2c_smbus_write_byte_data(client, reg, val);
	24	}
	25
	26	static int write_r8d16(void *client, u8 reg, u16 val)
	27	{
	28	return i2c_smbus_write_word_data(client, reg, val);
	29	}
	30
	31	static int read_d8(void *client)
	32	{
	33	return i2c_smbus_read_byte(client);
	34	}
	35
	36	static int read_r8d8(void *client, u8 reg)
	37	{
	38	return i2c_smbus_read_byte_data(client, reg);
	39	}
	40
	41	static int read_r8d16(void *client, u8 reg)
	42	{
	43	return i2c_smbus_read_word_data(client, reg);
	44	}
	45
	46	static const struct ad_dpot_bus_ops bops = {
	47	.read_d8 = read_d8,
	48	.read_r8d8 = read_r8d8,
	49	.read_r8d16 = read_r8d16,
	50	.write_d8 = write_d8,
	51	.write_r8d8 = write_r8d8,
	52	.write_r8d16 = write_r8d16,
	53	};
	54
	55	static int __devinit ad_dpot_i2c_probe(struct i2c_client *client,
	56	const struct i2c_device_id *id)
	57	{
	58	struct ad_dpot_bus_data bdata = {
	59	.client = client,
	60	.bops = &bops,
	61	};
	62
	63	struct ad_dpot_id dpot_id = {
	64	.name = (char *) &id->name,
65	.devid = id->driver_data,
66	};
67
68	if (!i2c_check_functionality(client->adapter,
69	I2C_FUNC_SMBUS_WORD_DATA)) {
70	dev_err(&client->dev, "SMBUS Word Data not Supported\n");
71	return -EIO;
72	}
73
74	return ad_dpot_probe(&client->dev, &bdata, &dpot_id);
75	}
76
77	static int __devexit ad_dpot_i2c_remove(struct i2c_client *client)
78	{
79	return ad_dpot_remove(&client->dev);
80	}
81
82	static const struct i2c_device_id ad_dpot_id[] = {
83	{"ad5258", AD5258_ID},
84	{"ad5259", AD5259_ID},
85	{"ad5251", AD5251_ID},
86	{"ad5252", AD5252_ID},
87	{"ad5253", AD5253_ID},
88	{"ad5254", AD5254_ID},
89	{"ad5255", AD5255_ID},
e3ae6847 MH	90	{"ad5241", AD5241_ID},
	91	{"ad5242", AD5242_ID},
	92	{"ad5243", AD5243_ID},
	93	{"ad5245", AD5245_ID},
	94	{"ad5246", AD5246_ID},
	95	{"ad5247", AD5247_ID},
	96	{"ad5248", AD5248_ID},
c74cba61 MH	97	{"ad5280", AD5280_ID},
	98	{"ad5282", AD5282_ID},
	99	{"adn2860", ADN2860_ID},
59592d0c MH	100	{"ad5273", AD5273_ID},
	101	{"ad5171", AD5171_ID},
	102	{"ad5170", AD5170_ID},
	103	{"ad5172", AD5172_ID},
	104	{"ad5173", AD5173_ID},
a4bd3949 MH	105	{"ad5272", AD5272_ID},
a4bd3949 MH	106	{"ad5274", AD5274_ID},
6c536e4c MH	107	{}
	108	};
	109	MODULE_DEVICE_TABLE(i2c, ad_dpot_id);
	110
	111	static struct i2c_driver ad_dpot_i2c_driver = {
	112	.driver = {
	113	.name = "ad_dpot",
	114	.owner = THIS_MODULE,
	115	},
	116	.probe = ad_dpot_i2c_probe,
	117	.remove = __devexit_p(ad_dpot_i2c_remove),
	118	.id_table = ad_dpot_id,
	119	};
	120
	121	static int __init ad_dpot_i2c_init(void)
	122	{
	123	return i2c_add_driver(&ad_dpot_i2c_driver);
	124	}
	125	module_init(ad_dpot_i2c_init);
	126
	127	static void __exit ad_dpot_i2c_exit(void)
	128	{
	129	i2c_del_driver(&ad_dpot_i2c_driver);
	130	}
	131	module_exit(ad_dpot_i2c_exit);
	132
	133	MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
	134	MODULE_DESCRIPTION("digital potentiometer I2C bus driver");
	135	MODULE_LICENSE("GPL");
	136	MODULE_ALIAS("i2c:ad_dpot");