int i2c_attach_client(struct i2c_client *client)
{
struct i2c_adapter *adapter = client->adapter;
int i;
if (i2c_check_addr(client->adapter,client->addr))
return -EBUSY;
for (i = 0; i < I2C_CLIENT_MAX; i++)
if (NULL == adapter->clients[i])
break;
if (I2C_CLIENT_MAX == i) {
printk(KERN_WARNING
" i2c-core.o: attach_client(%s) - enlarge I2C_CLIENT_MAX.\n",
client->name);
return -ENOMEM;
}
adapter->clients[i] = client;
adapter->client_count++;
if (adapter->client_register)
if (adapter->client_register(client))
printk(KERN_DEBUG "i2c-core.o: warning: client_register seems "
"to have failed for client %02x at adapter %s\n",
client->addr,adapter->name);
DEB(printk(KERN_DEBUG "i2c-core.o: client [%s] registered to adapter [%s](pos. %d).\n",
client->name, adapter->name,i));
if(client->flags & I2C_CLIENT_ALLOW_USE)
client->usage_count = 0;
return 0;
}
int xeno_i2c_ioctl(unsigned int cmd, unsigned long arg) {
switch (cmd) {
case I2C_SLAVE:
if ((arg > 0x3ff) || (((client->flags & I2C_M_TEN) == 0) && arg > 0x7f))
return -EINVAL;
if ((cmd == I2C_SLAVE) && i2c_check_addr(client->adapter, arg))
return -EBUSY;
client->addr = arg;
return 0;
default:
return i2c_control(client, cmd, arg);
}
return 0;
}
static int i2c_at24_probe(struct i2c_master *master, int argc, char **argv)
{
int addr;
int offset_len;
uint8_t buf[256];
(void)argc;
(void)argv;
addr = 0x50;
offset_len = 8;
if (!strcmp("spd", argv[0])) {
addr = 0x53;
} else if (!strcmp("at24c1024", argv[0])) {
offset_len = 16;
}
if (i2c_check_addr(master, addr)) {
printf("no at24 chip at addr=0x%02x\n", addr);
return -1;
}
i2c_start(master);
i2c_begin_write(master, addr);
i2c_rawwrite(master, 0x00);
if (offset_len == 16) {
i2c_rawwrite(master, 0x00);
}
i2c_stop(master);
i2c_start(master);
i2c_begin_read(master, addr);
i2c_read(master, &buf[0], 256);
i2c_stop(master);
memory_display(&buf[0], 0, 256, 1, 0);
return 0;
}
/* Very inefficient for ISA detects, and won't work for 10-bit addresses! */
int i2c_detect(struct i2c_adapter *adapter,
struct i2c_address_data *address_data,
i2c_found_addr_proc * found_proc)
{
int addr, i, found, j, err;
struct i2c_force_data *this_force;
int is_isa = i2c_is_isa_adapter(adapter);
int adapter_id =
is_isa ? SENSORS_ISA_BUS : i2c_adapter_id(adapter);
/* Forget it if we can't probe using SMBUS_QUICK */
if ((!is_isa)
&& !i2c_check_functionality(adapter,
I2C_FUNC_SMBUS_QUICK)) return -1;
for (addr = 0x00; addr <= (is_isa ? 0xffff : 0x7f); addr++) {
if ((is_isa && check_region(addr, 1)) ||
(!is_isa && i2c_check_addr(adapter, addr)))
continue;
/* If it is in one of the force entries, we don't do any
detection at all */
found = 0;
for (i = 0;
!found
&& (this_force =
address_data->forces + i, this_force->force); i++) {
for (j = 0;
!found
&& (this_force->force[j] != SENSORS_I2C_END);
j += 2) {
if (
((adapter_id == this_force->force[j])
||
((this_force->
force[j] == SENSORS_ANY_I2C_BUS)
&& !is_isa))
&& (addr == this_force->force[j + 1])) {
#ifdef DEBUG
printk
("i2c-proc.o: found force parameter for adapter %d, addr %04x\n",
adapter_id, addr);
#endif
if (
(err =
found_proc(adapter, addr, 0,
this_force->
kind))) return err;
found = 1;
}
}
}
if (found)
continue;
/* If this address is in one of the ignores, we can forget about it
right now */
for (i = 0;
!found
&& (address_data->ignore[i] != SENSORS_I2C_END);
i += 2) {
if (
((adapter_id == address_data->ignore[i])
||
((address_data->
ignore[i] == SENSORS_ANY_I2C_BUS)
&& !is_isa))
&& (addr == address_data->ignore[i + 1])) {
#ifdef DEBUG
printk
("i2c-proc.o: found ignore parameter for adapter %d, "
"addr %04x\n", adapter_id, addr);
#endif
found = 1;
}
}
for (i = 0;
!found
&& (address_data->ignore_range[i] != SENSORS_I2C_END);
i += 3) {
if (
((adapter_id == address_data->ignore_range[i])
||
((address_data->
ignore_range[i] ==
SENSORS_ANY_I2C_BUS) & !is_isa))
&& (addr >= address_data->ignore_range[i + 1])
&& (addr <= address_data->ignore_range[i + 2])) {
#ifdef DEBUG
printk
("i2c-proc.o: found ignore_range parameter for adapter %d, "
"addr %04x\n", adapter_id, addr);
#endif
found = 1;
}
}
if (found)
continue;
/* Now, we will do a detection, but only if it is in the normal or
probe entries */
if (is_isa) {
for (i = 0;
!found
&& (address_data->normal_isa[i] !=
SENSORS_ISA_END); i += 1) {
if (addr == address_data->normal_isa[i]) {
#ifdef DEBUG
printk
("i2c-proc.o: found normal isa entry for adapter %d, "
"addr %04x\n", adapter_id,
addr);
#endif
found = 1;
}
}
for (i = 0;
!found
&& (address_data->normal_isa_range[i] !=
SENSORS_ISA_END); i += 3) {
if ((addr >=
address_data->normal_isa_range[i])
&& (addr <=
address_data->normal_isa_range[i + 1])
&&
((addr -
address_data->normal_isa_range[i]) %
address_data->normal_isa_range[i + 2] ==
0)) {
#ifdef DEBUG
printk
("i2c-proc.o: found normal isa_range entry for adapter %d, "
"addr %04x", adapter_id, addr);
#endif
found = 1;
}
}
} else {
for (i = 0;
!found && (address_data->normal_i2c[i] !=
SENSORS_I2C_END); i += 1) {
if (addr == address_data->normal_i2c[i]) {
found = 1;
#ifdef DEBUG
printk
("i2c-proc.o: found normal i2c entry for adapter %d, "
"addr %02x", adapter_id, addr);
#endif
}
}
for (i = 0;
!found
&& (address_data->normal_i2c_range[i] !=
SENSORS_I2C_END); i += 2) {
if ((addr >=
address_data->normal_i2c_range[i])
&& (addr <=
address_data->normal_i2c_range[i + 1]))
{
#ifdef DEBUG
printk
("i2c-proc.o: found normal i2c_range entry for adapter %d, "
"addr %04x\n", adapter_id, addr);
#endif
found = 1;
}
}
}
for (i = 0;
!found && (address_data->probe[i] != SENSORS_I2C_END);
i += 2) {
if (((adapter_id == address_data->probe[i]) ||
((address_data->
probe[i] == SENSORS_ANY_I2C_BUS) & !is_isa))
&& (addr == address_data->probe[i + 1])) {
#ifdef DEBUG
printk
("i2c-proc.o: found probe parameter for adapter %d, "
"addr %04x\n", adapter_id, addr);
#endif
found = 1;
}
}
for (i = 0; !found &&
(address_data->probe_range[i] != SENSORS_I2C_END);
i += 3) {
if (
((adapter_id == address_data->probe_range[i])
||
((address_data->probe_range[i] ==
SENSORS_ANY_I2C_BUS) & !is_isa))
&& (addr >= address_data->probe_range[i + 1])
&& (addr <= address_data->probe_range[i + 2])) {
found = 1;
#ifdef DEBUG
printk
("i2c-proc.o: found probe_range parameter for adapter %d, "
"addr %04x\n", adapter_id, addr);
#endif
}
}
if (!found)
continue;
/* OK, so we really should examine this address. First check
whether there is some client here at all! */
if (is_isa ||
(i2c_smbus_xfer
(adapter, addr, 0, 0, 0, I2C_SMBUS_QUICK, NULL) >= 0))
if ((err = found_proc(adapter, addr, 0, -1)))
return err;
}
return 0;
}
int i2cdev_ioctl (struct inode *inode, struct file *file, unsigned int cmd,
unsigned long arg)
{
struct i2c_client *client = (struct i2c_client *)file->private_data;
struct i2c_rdwr_ioctl_data rdwr_arg;
struct i2c_smbus_ioctl_data data_arg;
union i2c_smbus_data temp;
struct i2c_msg *rdwr_pa;
u8 **data_ptrs;
int i,datasize,res;
unsigned long funcs;
#ifdef DEBUG
printk(KERN_DEBUG "i2c-dev.o: i2c-%d ioctl, cmd: 0x%x, arg: %lx.\n",
MINOR(inode->i_rdev),cmd, arg);
#endif /* DEBUG */
switch ( cmd ) {
case I2C_SLAVE:
case I2C_SLAVE_FORCE:
if ((arg > 0x3ff) ||
(((client->flags & I2C_M_TEN) == 0) && arg > 0x7f))
return -EINVAL;
if ((cmd == I2C_SLAVE) && i2c_check_addr(client->adapter,arg))
return -EBUSY;
client->addr = arg;
return 0;
case I2C_TENBIT:
if (arg)
client->flags |= I2C_M_TEN;
else
client->flags &= ~I2C_M_TEN;
return 0;
case I2C_FUNCS:
funcs = i2c_get_functionality(client->adapter);
return (copy_to_user((unsigned long *)arg,&funcs,
sizeof(unsigned long)))?-EFAULT:0;
case I2C_RDWR:
if (copy_from_user(&rdwr_arg,
(struct i2c_rdwr_ioctl_data *)arg,
sizeof(rdwr_arg)))
return -EFAULT;
/* Put an arbritrary limit on the number of messages that can
* be sent at once */
if (rdwr_arg.nmsgs > 42)
return -EINVAL;
rdwr_pa = (struct i2c_msg *)
kmalloc(rdwr_arg.nmsgs * sizeof(struct i2c_msg),
GFP_KERNEL);
if (rdwr_pa == NULL) return -ENOMEM;
if (copy_from_user(rdwr_pa, rdwr_arg.msgs,
rdwr_arg.nmsgs * sizeof(struct i2c_msg))) {
kfree(rdwr_pa);
return -EFAULT;
}
data_ptrs = (u8 **) kmalloc(rdwr_arg.nmsgs * sizeof(u8 *),
GFP_KERNEL);
if (data_ptrs == NULL) {
kfree(rdwr_pa);
return -ENOMEM;
}
res = 0;
for( i=0; i<rdwr_arg.nmsgs; i++ )
{
/* Limit the size of the message to a sane amount */
if (rdwr_pa[i].len > 8192) {
res = -EINVAL;
break;
}
data_ptrs[i] = rdwr_pa[i].buf;
rdwr_pa[i].buf = kmalloc(rdwr_pa[i].len, GFP_KERNEL);
if(rdwr_pa[i].buf == NULL)
{
res = -ENOMEM;
break;
}
if(copy_from_user(rdwr_pa[i].buf,
data_ptrs[i],
rdwr_pa[i].len))
{
++i; /* Needs to be kfreed too */
res = -EFAULT;
break;
}
}
if (res < 0) {
int j;
for (j = 0; j < i; ++j)
kfree(rdwr_pa[j].buf);
kfree(data_ptrs);
kfree(rdwr_pa);
return res;
}
res = i2c_transfer(client->adapter,
rdwr_pa,
rdwr_arg.nmsgs);
while(i-- > 0)
{
if( res>=0 && (rdwr_pa[i].flags & I2C_M_RD))
{
if(copy_to_user(
data_ptrs[i],
rdwr_pa[i].buf,
rdwr_pa[i].len))
{
res = -EFAULT;
}
}
kfree(rdwr_pa[i].buf);
}
kfree(data_ptrs);
kfree(rdwr_pa);
return res;
case I2C_SMBUS:
if (copy_from_user(&data_arg,
(struct i2c_smbus_ioctl_data *) arg,
sizeof(struct i2c_smbus_ioctl_data)))
return -EFAULT;
if ((data_arg.size != I2C_SMBUS_BYTE) &&
(data_arg.size != I2C_SMBUS_QUICK) &&
(data_arg.size != I2C_SMBUS_BYTE_DATA) &&
(data_arg.size != I2C_SMBUS_WORD_DATA) &&
(data_arg.size != I2C_SMBUS_PROC_CALL) &&
(data_arg.size != I2C_SMBUS_BLOCK_DATA) &&
(data_arg.size != I2C_SMBUS_I2C_BLOCK_DATA)) {
#ifdef DEBUG
printk(KERN_DEBUG "i2c-dev.o: size out of range (%x) in ioctl I2C_SMBUS.\n",
data_arg.size);
#endif
return -EINVAL;
}
/* Note that I2C_SMBUS_READ and I2C_SMBUS_WRITE are 0 and 1,
so the check is valid if size==I2C_SMBUS_QUICK too. */
if ((data_arg.read_write != I2C_SMBUS_READ) &&
(data_arg.read_write != I2C_SMBUS_WRITE)) {
#ifdef DEBUG
printk(KERN_DEBUG "i2c-dev.o: read_write out of range (%x) in ioctl I2C_SMBUS.\n",
data_arg.read_write);
#endif
return -EINVAL;
}
/* Note that command values are always valid! */
if ((data_arg.size == I2C_SMBUS_QUICK) ||
((data_arg.size == I2C_SMBUS_BYTE) &&
(data_arg.read_write == I2C_SMBUS_WRITE)))
/* These are special: we do not use data */
return i2c_smbus_xfer(client->adapter, client->addr,
client->flags,
data_arg.read_write,
data_arg.command,
data_arg.size, NULL);
if (data_arg.data == NULL) {
#ifdef DEBUG
printk(KERN_DEBUG "i2c-dev.o: data is NULL pointer in ioctl I2C_SMBUS.\n");
#endif
return -EINVAL;
}
if ((data_arg.size == I2C_SMBUS_BYTE_DATA) ||
(data_arg.size == I2C_SMBUS_BYTE))
datasize = sizeof(data_arg.data->byte);
else if ((data_arg.size == I2C_SMBUS_WORD_DATA) ||
(data_arg.size == I2C_SMBUS_PROC_CALL))
datasize = sizeof(data_arg.data->word);
else /* size == I2C_SMBUS_BLOCK_DATA */
datasize = sizeof(data_arg.data->block);
if ((data_arg.size == I2C_SMBUS_PROC_CALL) ||
(data_arg.read_write == I2C_SMBUS_WRITE)) {
if (copy_from_user(&temp, data_arg.data, datasize))
return -EFAULT;
}
res = i2c_smbus_xfer(client->adapter,client->addr,client->flags,
data_arg.read_write,
data_arg.command,data_arg.size,&temp);
if (! res && ((data_arg.size == I2C_SMBUS_PROC_CALL) ||
(data_arg.read_write == I2C_SMBUS_READ))) {
if (copy_to_user(data_arg.data, &temp, datasize))
return -EFAULT;
}
return res;
default:
return i2c_control(client,cmd,arg);
}
return 0;
}
/* Very inefficient for ISA detects, and won't work for 10-bit addresses! */
int i2c_detect(struct i2c_adapter *adapter,
struct i2c_address_data *address_data,
int (*found_proc) (struct i2c_adapter *, int, int))
{
int addr, i, found, j, err;
struct i2c_force_data *this_force;
int is_isa = i2c_is_isa_adapter(adapter);
int adapter_id =
is_isa ? ANY_I2C_ISA_BUS : i2c_adapter_id(adapter);
unsigned short *normal_i2c;
unsigned int *normal_isa;
unsigned short *probe;
unsigned short *ignore;
/* Forget it if we can't probe using SMBUS_QUICK */
if ((!is_isa) &&
!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK))
return -1;
/* Use default "empty" list if the adapter doesn't specify any */
normal_i2c = probe = ignore = empty;
normal_isa = empty_isa;
if (address_data->normal_i2c)
normal_i2c = address_data->normal_i2c;
if (address_data->normal_isa)
normal_isa = address_data->normal_isa;
if (address_data->probe)
probe = address_data->probe;
if (address_data->ignore)
ignore = address_data->ignore;
for (addr = 0x00; addr <= (is_isa ? 0xffff : 0x7f); addr++) {
if (!is_isa && i2c_check_addr(adapter, addr))
continue;
/* If it is in one of the force entries, we don't do any
detection at all */
found = 0;
for (i = 0; !found && (this_force = address_data->forces + i, this_force->force); i++) {
for (j = 0; !found && (this_force->force[j] != I2C_CLIENT_END); j += 2) {
if ( ((adapter_id == this_force->force[j]) ||
((this_force->force[j] == ANY_I2C_BUS) && !is_isa)) &&
(addr == this_force->force[j + 1]) ) {
dev_dbg(&adapter->dev, "found force parameter for adapter %d, addr %04x\n", adapter_id, addr);
if ((err = found_proc(adapter, addr, this_force->kind)))
return err;
found = 1;
}
}
}
if (found)
continue;
/* If this address is in one of the ignores, we can forget about it
right now */
for (i = 0; !found && (ignore[i] != I2C_CLIENT_END); i += 2) {
if ( ((adapter_id == ignore[i]) ||
((ignore[i] == ANY_I2C_BUS) &&
!is_isa)) &&
(addr == ignore[i + 1])) {
dev_dbg(&adapter->dev, "found ignore parameter for adapter %d, addr %04x\n", adapter_id, addr);
found = 1;
}
}
if (found)
continue;
/* Now, we will do a detection, but only if it is in the normal or
probe entries */
if (is_isa) {
for (i = 0; !found && (normal_isa[i] != I2C_CLIENT_ISA_END); i += 1) {
if (addr == normal_isa[i]) {
dev_dbg(&adapter->dev, "found normal isa entry for adapter %d, addr %04x\n", adapter_id, addr);
found = 1;
}
}
} else {
for (i = 0; !found && (normal_i2c[i] != I2C_CLIENT_END); i += 1) {
if (addr == normal_i2c[i]) {
found = 1;
dev_dbg(&adapter->dev, "found normal i2c entry for adapter %d, addr %02x\n", adapter_id, addr);
}
}
}
for (i = 0;
!found && (probe[i] != I2C_CLIENT_END);
i += 2) {
if (((adapter_id == probe[i]) ||
((probe[i] == ANY_I2C_BUS) && !is_isa))
&& (addr == probe[i + 1])) {
dev_dbg(&adapter->dev, "found probe parameter for adapter %d, addr %04x\n", adapter_id, addr);
found = 1;
}
}
if (!found)
continue;
/* OK, so we really should examine this address. First check
whether there is some client here at all! */
if (is_isa ||
(i2c_smbus_xfer (adapter, addr, 0, 0, 0, I2C_SMBUS_QUICK, NULL) >= 0))
if ((err = found_proc(adapter, addr, -1)))
return err;
}
return 0;
}