Skip to content

L
linux
Commit bc769ff8 authored by bgardner@wabtec.com's avatar bgardner@wabtec.com Committed by Greg Kroah-Hartman
Browse files
Options

[PATCH] I2C: simplify max6875 driver 

This is an update to the max6875 driver.
It no longer does any detection, so the address must be forced on module load.
It only makes available the user EEPROM (read-only).

This patch is based off 2.6.13-rc2-mm2.
Signed-off-by: default avatarBen Gardner <bgardner@wabtec.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent da1f136c
Show whitespace changes
Inline Side-by-side
Showing with 123 additions and 322 deletions
drivers/i2c/chips/max6875.c
View file @ bc769ff8
...@@ -5,97 +5,62 @@ ...@@ -5,97 +5,62 @@
Based on i2c/chips/eeprom.c Based on i2c/chips/eeprom.c
The MAX6875 has two EEPROM sections: config and user. The MAX6875 has a bank of registers and two banks of EEPROM.
At reset, the config EEPROM is read into the registers. Address ranges are defined as follows:
* 0x0000 - 0x0046 = configuration registers
* 0x8000 - 0x8046 = configuration EEPROM
* 0x8100 - 0x82FF = user EEPROM
This driver make 3 binary files available in sysfs: This driver makes the user EEPROM available for read.
reg_config - direct access to the registers
eeprom_config - acesses configuration eeprom space
eeprom_user - free for application use
In our application, we put device serial & model numbers in user eeprom. The registers & config EEPROM should be accessed via i2c-dev.
Notes: The MAX6875 ignores the lowest address bit, so each chip responds to
1) The datasheet says that register 0x44 / EEPROM 0x8044 should NOT two addresses - 0x50/0x51 and 0x52/0x53.
be overwritten, so the driver explicitly prevents that.
2) It's a good idea to keep the config (0x45) locked in config EEPROM. Note that the MAX6875 uses i2c_smbus_write_byte_data() to set the read
You can temporarily enable config writes by changing register 0x45. address, so this driver is destructive if loaded for the wrong EEPROM chip.
This program is free software; you can redistribute it and/or modify This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License. the Free Software Foundation; version 2 of the License.
*/ */
#include <linux/config.h>
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/sched.h>
#include <linux/delay.h>
#include <linux/i2c.h> #include <linux/i2c.h>
#include <linux/i2c-sensor.h> #include <linux/i2c-sensor.h>
#include <asm/semaphore.h>
/* Addresses to scan */ /* Do not scan - the MAX6875 access method will write to some EEPROM chips */
/* No address scanned by default, as this could corrupt standard EEPROMS. */
static unsigned short normal_i2c[] = {I2C_CLIENT_END}; static unsigned short normal_i2c[] = {I2C_CLIENT_END};
static unsigned int normal_isa[] = {I2C_CLIENT_ISA_END}; static unsigned int normal_isa[] = {I2C_CLIENT_ISA_END};
/* Insmod parameters */ /* Insmod parameters */
SENSORS_INSMOD_1(max6875); SENSORS_INSMOD_1(max6875);
/* this param will prevent 'accidental' writes to the eeprom */
static int allow_write = 0;
module_param(allow_write, int, 0);
MODULE_PARM_DESC(allow_write,
"Enable write access:\n"
"*0: Read only\n"
" 1: Read/Write access");
/* The MAX6875 can only read/write 16 bytes at a time */ /* The MAX6875 can only read/write 16 bytes at a time */
#define SLICE_SIZE 16 #define SLICE_SIZE 16
#define SLICE_BITS 4 #define SLICE_BITS 4
/* CONFIG EEPROM is at addresses 0x8000 - 0x8045, registers are at 0 - 0x45 */
#define CONFIG_EEPROM_BASE 0x8000
#define CONFIG_EEPROM_SIZE 0x0046
#define CONFIG_EEPROM_SLICES 5
/* USER EEPROM is at addresses 0x8100 - 0x82FF */ /* USER EEPROM is at addresses 0x8100 - 0x82FF */
#define USER_EEPROM_BASE 0x8100 #define USER_EEPROM_BASE 0x8100
#define USER_EEPROM_SIZE 0x0200 #define USER_EEPROM_SIZE 0x0200
#define USER_EEPROM_SLICES 32 #define USER_EEPROM_SLICES 32
/* MAX6875 commands */ /* MAX6875 commands */
#define MAX6875_CMD_BLOCK_WRITE 0x83 #define MAX6875_CMD_BLK_READ 0x84
#define MAX6875_CMD_BLOCK_READ 0x84
#define MAX6875_CMD_REBOOT 0x88
enum max6875_area_type {
max6875_register_config=0,
max6875_eeprom_config,
max6875_eeprom_user,
max6857_max
};
struct eeprom_block {
enum max6875_area_type type;
u8 slices;
u32 size;
u32 valid;
u32 base;
unsigned long *updated;
u8 *data;
};
/* Each client has this additional data */ /* Each client has this additional data */
struct max6875_data { struct max6875_data {
struct i2c_client client; struct i2c_client client;
struct semaphore update_lock; struct semaphore update_lock;
struct eeprom_block blocks[max6857_max];
/* the above structs point into the arrays below */ u32 valid;
u8 data[USER_EEPROM_SIZE + (CONFIG_EEPROM_SIZE*2)]; u8 data[USER_EEPROM_SIZE];
unsigned long last_updated[USER_EEPROM_SLICES + (CONFIG_EEPROM_SLICES*2)]; unsigned long last_updated[USER_EEPROM_SLICES];
}; };
static int max6875_attach_adapter(struct i2c_adapter *adapter); static int max6875_attach_adapter(struct i2c_adapter *adapter);
...@@ -111,224 +76,98 @@ static struct i2c_driver max6875_driver = { ...@@ -111,224 +76,98 @@ static struct i2c_driver max6875_driver = {
.detach_client = max6875_detach_client, .detach_client = max6875_detach_client,
}; };
static int max6875_update_slice(struct i2c_client *client, static void max6875_update_slice(struct i2c_client *client, int slice)
struct eeprom_block *blk,
int slice)
{ {
struct max6875_data *data = i2c_get_clientdata(client); struct max6875_data *data = i2c_get_clientdata(client);
int i, j, addr, count; int i, j, addr;
u8 rdbuf[SLICE_SIZE]; u8 *buf;
int retval = 0; int retval = 0;
if (slice >= blk->slices) if (slice >= USER_EEPROM_SLICES)
return -1; return;
down(&data->update_lock); down(&data->update_lock);
if (!(blk->valid & (1 << slice)) || buf = &data->data[slice << SLICE_BITS];
(jiffies - blk->updated[slice] > 300 * HZ) ||
(jiffies < blk->updated[slice])) { if (!(data->valid & (1 << slice)) ||
dev_dbg(&client->dev, "Starting eeprom update, slice %u, base %u\n", time_after(jiffies, data->last_updated[slice])) {
dev_dbg(&client->dev, "Starting update of slice %u\n",
slice, blk->base); slice, blk->base);
addr = blk->base + (slice << SLICE_BITS); data->valid &= ~(1 << slice);
count = blk->size - (slice << SLICE_BITS);
if (count > SLICE_SIZE) {
count = SLICE_SIZE;
}
/* Preset the read address */ addr = USER_EEPROM_BASE + (slice << SLICE_BITS);
if (addr < 0x100) {
/* select the register */ /* select the eeprom address */
if (i2c_smbus_write_byte(client, addr & 0xFF)) {
dev_dbg(&client->dev, "max6875 register select has failed!\n");
retval = -1;
goto exit;
}
} else {
/* select the eeprom */
if (i2c_smbus_write_byte_data(client, addr >> 8, addr & 0xFF)) { if (i2c_smbus_write_byte_data(client, addr >> 8, addr & 0xFF)) {
dev_dbg(&client->dev, "max6875 address set has failed!\n"); dev_err(&client->dev, "address set failed\n");
retval = -1; retval = -1;
goto exit; goto exit_up;
}
} }
if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK)) { if (i2c_check_functionality(client->adapter,
if (i2c_smbus_read_i2c_block_data(client, MAX6875_CMD_BLOCK_READ, I2C_FUNC_SMBUS_READ_I2C_BLOCK)) {
rdbuf) != SLICE_SIZE) if (i2c_smbus_read_i2c_block_data(client,
{ MAX6875_CMD_BLK_READ,
buf) != SLICE_SIZE) {
retval = -1; retval = -1;
goto exit; goto exit_up;
} }
memcpy(&blk->data[slice << SLICE_BITS], rdbuf, count);
} else { } else {
for (i = 0; i < count; i++) { for (i = 0; i < SLICE_SIZE; i++) {
j = i2c_smbus_read_byte(client); j = i2c_smbus_read_byte(client);
if (j < 0) if (j < 0) {
{
retval = -1; retval = -1;
goto exit; goto exit_up;
} }
blk->data[(slice << SLICE_BITS) + i] = (u8) j; buf[i] = j;
} }
} }
blk->updated[slice] = jiffies; data->last_updated[slice] = jiffies;
blk->valid |= (1 << slice); data->valid |= (1 << slice);
} }
exit: exit_up:
up(&data->update_lock); up(&data->update_lock);
return retval;
}
static ssize_t max6875_read(struct kobject *kobj, char *buf, loff_t off, size_t count,
enum max6875_area_type area_type)
{
struct i2c_client *client = to_i2c_client(container_of(kobj, struct device, kobj));
struct max6875_data *data = i2c_get_clientdata(client);
struct eeprom_block *blk;
int slice;
blk = &data->blocks[area_type];
if (off > blk->size)
return 0;
if (off + count > blk->size)
count = blk->size - off;
/* Only refresh slices which contain requested bytes */
for (slice = (off >> SLICE_BITS); slice <= ((off + count - 1) >> SLICE_BITS); slice++)
max6875_update_slice(client, blk, slice);
memcpy(buf, &blk->data[off], count);
return count;
}
static ssize_t max6875_user_read(struct kobject *kobj, char *buf, loff_t off, size_t count)
{
return max6875_read(kobj, buf, off, count, max6875_eeprom_user);
}
static ssize_t max6875_config_read(struct kobject *kobj, char *buf, loff_t off, size_t count)
{
return max6875_read(kobj, buf, off, count, max6875_eeprom_config);
} }
static ssize_t max6875_cfgreg_read(struct kobject *kobj, char *buf, loff_t off, size_t count) static inline struct i2c_client *kobj_to_i2c_client(struct kobject *kobj)
{ {
return max6875_read(kobj, buf, off, count, max6875_register_config); return to_i2c_client(container_of(kobj, struct device, kobj));
} }
static ssize_t max6875_read(struct kobject *kobj, char *buf, loff_t off,
static ssize_t max6875_write(struct kobject *kobj, char *buf, loff_t off, size_t count, size_t count)
enum max6875_area_type area_type)
{ {
struct i2c_client *client = to_i2c_client(container_of(kobj, struct device, kobj)); struct i2c_client *client = kobj_to_i2c_client(kobj);
struct max6875_data *data = i2c_get_clientdata(client); struct max6875_data *data = i2c_get_clientdata(client);
struct eeprom_block *blk; int slice, max_slice;
int slice, addr, retval;
ssize_t sent = 0;
blk = &data->blocks[area_type]; if (off > USER_EEPROM_SIZE)
if (off > blk->size)
return 0; return 0;
if ((off + count) > blk->size)
count = blk->size - off;
if (down_interruptible(&data->update_lock)) if (off + count > USER_EEPROM_SIZE)
return -EAGAIN; count = USER_EEPROM_SIZE - off;
/* writing to a register is done with i2c_smbus_write_byte_data() */ /* refresh slices which contain requested bytes */
if (blk->type == max6875_register_config) { max_slice = (off + count - 1) >> SLICE_BITS;
for (sent = 0; sent < count; sent++) { for (slice = (off >> SLICE_BITS); slice <= max_slice; slice++)
addr = off + sent; max6875_update_slice(client, slice);
if (addr == 0x44)
continue;
retval = i2c_smbus_write_byte_data(client, addr, buf[sent]); memcpy(buf, &data->data[off], count);
}
} else {
int cmd, val;
/* We are writing to EEPROM */
for (sent = 0; sent < count; sent++) {
addr = blk->base + off + sent;
cmd = addr >> 8;
val = (addr & 0xff) | (buf[sent] << 8); // reversed
if (addr == 0x8044)
continue;
retval = i2c_smbus_write_word_data(client, cmd, val);
if (retval) {
goto error_exit;
}
/* A write takes up to 11 ms */ return count;
msleep(11);
}
}
/* Invalidate the scratch buffer */
for (slice = (off >> SLICE_BITS); slice <= ((off + count - 1) >> SLICE_BITS); slice++)
blk->valid &= ~(1 << slice);
error_exit:
up(&data->update_lock);
return sent;
}
static ssize_t max6875_user_write(struct kobject *kobj, char *buf, loff_t off, size_t count)
{
return max6875_write(kobj, buf, off, count, max6875_eeprom_user);
}
static ssize_t max6875_config_write(struct kobject *kobj, char *buf, loff_t off, size_t count)
{
return max6875_write(kobj, buf, off, count, max6875_eeprom_config);
}
static ssize_t max6875_cfgreg_write(struct kobject *kobj, char *buf, loff_t off, size_t count)
{
return max6875_write(kobj, buf, off, count, max6875_register_config);
} }
static struct bin_attribute user_eeprom_attr = { static struct bin_attribute user_eeprom_attr = {
.attr = { .attr = {
.name = "eeprom_user", .name = "eeprom",
.mode = S_IRUGO | S_IWUSR | S_IWGRP, .mode = S_IRUGO,
.owner = THIS_MODULE, .owner = THIS_MODULE,
}, },
.size = USER_EEPROM_SIZE, .size = USER_EEPROM_SIZE,
.read = max6875_user_read, .read = max6875_read,
.write = max6875_user_write,
};
static struct bin_attribute config_eeprom_attr = {
.attr = {
.name = "eeprom_config",
.mode = S_IRUGO | S_IWUSR,
.owner = THIS_MODULE,
},
.size = CONFIG_EEPROM_SIZE,
.read = max6875_config_read,
.write = max6875_config_write,
};
static struct bin_attribute config_register_attr = {
.attr = {
.name = "reg_config",
.mode = S_IRUGO | S_IWUSR,
.owner = THIS_MODULE,
},
.size = CONFIG_EEPROM_SIZE,
.read = max6875_cfgreg_read,
.write = max6875_cfgreg_write,
}; };
static int max6875_attach_adapter(struct i2c_adapter *adapter) static int max6875_attach_adapter(struct i2c_adapter *adapter)
...@@ -339,109 +178,73 @@ static int max6875_attach_adapter(struct i2c_adapter *adapter) ...@@ -339,109 +178,73 @@ static int max6875_attach_adapter(struct i2c_adapter *adapter)
/* This function is called by i2c_detect */ /* This function is called by i2c_detect */
static int max6875_detect(struct i2c_adapter *adapter, int address, int kind) static int max6875_detect(struct i2c_adapter *adapter, int address, int kind)
{ {
struct i2c_client *new_client; struct i2c_client *real_client;
struct i2c_client *fake_client;
struct max6875_data *data; struct max6875_data *data;
int err = 0; int err = 0;
/* Prevent 24RF08 corruption (in case of user error) */ /* Prevent 24rf08 corruption (in case of user error) */
if (kind < 0) if (kind < 0)
i2c_smbus_xfer(adapter, address, 0, 0, 0, i2c_smbus_xfer(adapter, address, 0, 0, 0,
I2C_SMBUS_QUICK, NULL); I2C_SMBUS_QUICK, NULL);
/* There are three ways we can read the EEPROM data: if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA
(1) I2C block reads (faster, but unsupported by most adapters) | I2C_FUNC_SMBUS_READ_BYTE))
(2) Consecutive byte reads (100% overhead) return 0;
(3) Regular byte data reads (200% overhead)
The third method is not implemented by this driver because all /* Only check even addresses */
known adapters support at least the second. */ if (address & 1)
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA | return 0;
I2C_FUNC_SMBUS_BYTE |
I2C_FUNC_SMBUS_WRITE_BYTE_DATA)) if (!(data = kmalloc(sizeof(struct max6875_data), GFP_KERNEL)))
goto exit; return -ENOMEM;
/* OK. For now, we presume we have a valid client. We now create the
client structure, even though we cannot fill it completely yet.
But it allows us to access eeprom_{read,write}_value. */
if (!(data = kmalloc(sizeof(struct max6875_data), GFP_KERNEL))) {
err = -ENOMEM;
goto exit;
}
memset(data, 0, sizeof(struct max6875_data)); memset(data, 0, sizeof(struct max6875_data));
new_client = &data->client; /* A fake client is created on the odd address */
i2c_set_clientdata(new_client, data); if (!(fake_client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL))) {
new_client->addr = address; err = -ENOMEM;
new_client->adapter = adapter; goto exit_kfree1;
new_client->driver = &max6875_driver; }
new_client->flags = 0; memset(fake_client, 0, sizeof(struct i2c_client));
/* Setup the user section */ /* Init real i2c_client */
data->blocks[max6875_eeprom_user].type = max6875_eeprom_user; real_client = &data->client;
data->blocks[max6875_eeprom_user].slices = USER_EEPROM_SLICES; i2c_set_clientdata(real_client, data);
data->blocks[max6875_eeprom_user].size = USER_EEPROM_SIZE; real_client->addr = address;
data->blocks[max6875_eeprom_user].base = USER_EEPROM_BASE; real_client->adapter = adapter;
data->blocks[max6875_eeprom_user].data = data->data; real_client->driver = &max6875_driver;
data->blocks[max6875_eeprom_user].updated = data->last_updated; real_client->flags = 0;
strlcpy(real_client->name, "max6875", I2C_NAME_SIZE);
/* Setup the config section */
data->blocks[max6875_eeprom_config].type = max6875_eeprom_config;
data->blocks[max6875_eeprom_config].slices = CONFIG_EEPROM_SLICES;
data->blocks[max6875_eeprom_config].size = CONFIG_EEPROM_SIZE;
data->blocks[max6875_eeprom_config].base = CONFIG_EEPROM_BASE;
data->blocks[max6875_eeprom_config].data = &data->data[USER_EEPROM_SIZE];
data->blocks[max6875_eeprom_config].updated = &data->last_updated[USER_EEPROM_SLICES];
/* Setup the register section */
data->blocks[max6875_register_config].type = max6875_register_config;
data->blocks[max6875_register_config].slices = CONFIG_EEPROM_SLICES;
data->blocks[max6875_register_config].size = CONFIG_EEPROM_SIZE;
data->blocks[max6875_register_config].base = 0;
data->blocks[max6875_register_config].data = &data->data[USER_EEPROM_SIZE+CONFIG_EEPROM_SIZE];
data->blocks[max6875_register_config].updated = &data->last_updated[USER_EEPROM_SLICES+CONFIG_EEPROM_SLICES];
/* Init the data */
memset(data->data, 0xff, sizeof(data->data));
/* Fill in the remaining client fields */
strlcpy(new_client->name, "max6875", I2C_NAME_SIZE);
init_MUTEX(&data->update_lock); init_MUTEX(&data->update_lock);
/* Verify that the chip is really what we think it is */ /* Init fake client data */
if ((max6875_update_slice(new_client, &data->blocks[max6875_eeprom_config], 4) < 0) || /* set the client data to the i2c_client so that it will get freed */
(max6875_update_slice(new_client, &data->blocks[max6875_register_config], 4) < 0)) i2c_set_clientdata(fake_client, fake_client);
goto exit_kfree; fake_client->addr = address | 1;
fake_client->adapter = adapter;
/* 0x41,0x42 must be zero and 0x40 must match in eeprom and registers */ fake_client->driver = &max6875_driver;
if ((data->blocks[max6875_eeprom_config].data[0x41] != 0) || fake_client->flags = 0;
(data->blocks[max6875_eeprom_config].data[0x42] != 0) || strlcpy(fake_client->name, "max6875-dummy", I2C_NAME_SIZE);
(data->blocks[max6875_register_config].data[0x41] != 0) ||
(data->blocks[max6875_register_config].data[0x42] != 0) || /* Prevent 24RF08 corruption (in case of user error) */
(data->blocks[max6875_eeprom_config].data[0x40] != i2c_smbus_write_quick(real_client, 0);
data->blocks[max6875_register_config].data[0x40]))
goto exit_kfree; if ((err = i2c_attach_client(real_client)) != 0)
goto exit_kfree2;
/* Tell the I2C layer a new client has arrived */
if ((err = i2c_attach_client(new_client))) if ((err = i2c_attach_client(fake_client)) != 0)
goto exit_kfree; goto exit_detach;
/* create the sysfs eeprom files with the correct permissions */ sysfs_create_bin_file(&real_client->dev.kobj, &user_eeprom_attr);
if (allow_write == 0) {
user_eeprom_attr.attr.mode &= ~S_IWUGO;
user_eeprom_attr.write = NULL;
config_eeprom_attr.attr.mode &= ~S_IWUGO;
config_eeprom_attr.write = NULL;
config_register_attr.attr.mode &= ~S_IWUGO;
config_register_attr.write = NULL;
}
sysfs_create_bin_file(&new_client->dev.kobj, &user_eeprom_attr);
sysfs_create_bin_file(&new_client->dev.kobj, &config_eeprom_attr);
sysfs_create_bin_file(&new_client->dev.kobj, &config_register_attr);
return 0; return 0;
exit_kfree: exit_detach:
i2c_detach_client(real_client);
exit_kfree2:
kfree(fake_client);
exit_kfree1:
kfree(data); kfree(data);
exit:
return err; return err;
} }
...@@ -451,12 +254,10 @@ static int max6875_detach_client(struct i2c_client *client) ...@@ -451,12 +254,10 @@ static int max6875_detach_client(struct i2c_client *client)
err = i2c_detach_client(client); err = i2c_detach_client(client);
if (err) { if (err) {
dev_err(&client->dev, "Client deregistration failed, client not detached.\n"); dev_err(&client->dev, "i2c_detach_client() failed\n");
return err; return err;
} }
kfree(i2c_get_clientdata(client)); kfree(i2c_get_clientdata(client));
return 0; return 0;
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7