| 1 | /* |
| 2 | * max6875.c - driver for MAX6874/MAX6875 |
| 3 | * |
| 4 | * Copyright (C) 2005 Ben Gardner <bgardner@wabtec.com> |
| 5 | * |
| 6 | * Based on eeprom.c |
| 7 | * |
| 8 | * The MAX6875 has a bank of registers and two banks of EEPROM. |
| 9 | * Address ranges are defined as follows: |
| 10 | * * 0x0000 - 0x0046 = configuration registers |
| 11 | * * 0x8000 - 0x8046 = configuration EEPROM |
| 12 | * * 0x8100 - 0x82FF = user EEPROM |
| 13 | * |
| 14 | * This driver makes the user EEPROM available for read. |
| 15 | * |
| 16 | * The registers & config EEPROM should be accessed via i2c-dev. |
| 17 | * |
| 18 | * The MAX6875 ignores the lowest address bit, so each chip responds to |
| 19 | * two addresses - 0x50/0x51 and 0x52/0x53. |
| 20 | * |
| 21 | * Note that the MAX6875 uses i2c_smbus_write_byte_data() to set the read |
| 22 | * address, so this driver is destructive if loaded for the wrong EEPROM chip. |
| 23 | * |
| 24 | * This program is free software; you can redistribute it and/or modify |
| 25 | * it under the terms of the GNU General Public License as published by |
| 26 | * the Free Software Foundation; version 2 of the License. |
| 27 | */ |
| 28 | |
| 29 | #include <linux/kernel.h> |
| 30 | #include <linux/module.h> |
| 31 | #include <linux/slab.h> |
| 32 | #include <linux/i2c.h> |
| 33 | #include <linux/mutex.h> |
| 34 | |
| 35 | /* The MAX6875 can only read/write 16 bytes at a time */ |
| 36 | #define SLICE_SIZE 16 |
| 37 | #define SLICE_BITS 4 |
| 38 | |
| 39 | /* USER EEPROM is at addresses 0x8100 - 0x82FF */ |
| 40 | #define USER_EEPROM_BASE 0x8100 |
| 41 | #define USER_EEPROM_SIZE 0x0200 |
| 42 | #define USER_EEPROM_SLICES 32 |
| 43 | |
| 44 | /* MAX6875 commands */ |
| 45 | #define MAX6875_CMD_BLK_READ 0x84 |
| 46 | |
| 47 | /* Each client has this additional data */ |
| 48 | struct max6875_data { |
| 49 | struct i2c_client *fake_client; |
| 50 | struct mutex update_lock; |
| 51 | |
| 52 | u32 valid; |
| 53 | u8 data[USER_EEPROM_SIZE]; |
| 54 | unsigned long last_updated[USER_EEPROM_SLICES]; |
| 55 | }; |
| 56 | |
| 57 | static void max6875_update_slice(struct i2c_client *client, int slice) |
| 58 | { |
| 59 | struct max6875_data *data = i2c_get_clientdata(client); |
| 60 | int i, j, addr; |
| 61 | u8 *buf; |
| 62 | |
| 63 | if (slice >= USER_EEPROM_SLICES) |
| 64 | return; |
| 65 | |
| 66 | mutex_lock(&data->update_lock); |
| 67 | |
| 68 | buf = &data->data[slice << SLICE_BITS]; |
| 69 | |
| 70 | if (!(data->valid & (1 << slice)) || |
| 71 | time_after(jiffies, data->last_updated[slice])) { |
| 72 | |
| 73 | dev_dbg(&client->dev, "Starting update of slice %u\n", slice); |
| 74 | |
| 75 | data->valid &= ~(1 << slice); |
| 76 | |
| 77 | addr = USER_EEPROM_BASE + (slice << SLICE_BITS); |
| 78 | |
| 79 | /* select the eeprom address */ |
| 80 | if (i2c_smbus_write_byte_data(client, addr >> 8, addr & 0xFF)) { |
| 81 | dev_err(&client->dev, "address set failed\n"); |
| 82 | goto exit_up; |
| 83 | } |
| 84 | |
| 85 | if (i2c_check_functionality(client->adapter, |
| 86 | I2C_FUNC_SMBUS_READ_I2C_BLOCK)) { |
| 87 | if (i2c_smbus_read_i2c_block_data(client, |
| 88 | MAX6875_CMD_BLK_READ, |
| 89 | SLICE_SIZE, |
| 90 | buf) != SLICE_SIZE) { |
| 91 | goto exit_up; |
| 92 | } |
| 93 | } else { |
| 94 | for (i = 0; i < SLICE_SIZE; i++) { |
| 95 | j = i2c_smbus_read_byte(client); |
| 96 | if (j < 0) { |
| 97 | goto exit_up; |
| 98 | } |
| 99 | buf[i] = j; |
| 100 | } |
| 101 | } |
| 102 | data->last_updated[slice] = jiffies; |
| 103 | data->valid |= (1 << slice); |
| 104 | } |
| 105 | exit_up: |
| 106 | mutex_unlock(&data->update_lock); |
| 107 | } |
| 108 | |
| 109 | static ssize_t max6875_read(struct file *filp, struct kobject *kobj, |
| 110 | struct bin_attribute *bin_attr, |
| 111 | char *buf, loff_t off, size_t count) |
| 112 | { |
| 113 | struct i2c_client *client = kobj_to_i2c_client(kobj); |
| 114 | struct max6875_data *data = i2c_get_clientdata(client); |
| 115 | int slice, max_slice; |
| 116 | |
| 117 | /* refresh slices which contain requested bytes */ |
| 118 | max_slice = (off + count - 1) >> SLICE_BITS; |
| 119 | for (slice = (off >> SLICE_BITS); slice <= max_slice; slice++) |
| 120 | max6875_update_slice(client, slice); |
| 121 | |
| 122 | memcpy(buf, &data->data[off], count); |
| 123 | |
| 124 | return count; |
| 125 | } |
| 126 | |
| 127 | static struct bin_attribute user_eeprom_attr = { |
| 128 | .attr = { |
| 129 | .name = "eeprom", |
| 130 | .mode = S_IRUGO, |
| 131 | }, |
| 132 | .size = USER_EEPROM_SIZE, |
| 133 | .read = max6875_read, |
| 134 | }; |
| 135 | |
| 136 | static int max6875_probe(struct i2c_client *client, |
| 137 | const struct i2c_device_id *id) |
| 138 | { |
| 139 | struct i2c_adapter *adapter = client->adapter; |
| 140 | struct max6875_data *data; |
| 141 | int err; |
| 142 | |
| 143 | if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WRITE_BYTE_DATA |
| 144 | | I2C_FUNC_SMBUS_READ_BYTE)) |
| 145 | return -ENODEV; |
| 146 | |
| 147 | /* Only bind to even addresses */ |
| 148 | if (client->addr & 1) |
| 149 | return -ENODEV; |
| 150 | |
| 151 | if (!(data = kzalloc(sizeof(struct max6875_data), GFP_KERNEL))) |
| 152 | return -ENOMEM; |
| 153 | |
| 154 | /* A fake client is created on the odd address */ |
| 155 | data->fake_client = i2c_new_dummy(client->adapter, client->addr + 1); |
| 156 | if (!data->fake_client) { |
| 157 | err = -ENOMEM; |
| 158 | goto exit_kfree; |
| 159 | } |
| 160 | |
| 161 | /* Init real i2c_client */ |
| 162 | i2c_set_clientdata(client, data); |
| 163 | mutex_init(&data->update_lock); |
| 164 | |
| 165 | err = sysfs_create_bin_file(&client->dev.kobj, &user_eeprom_attr); |
| 166 | if (err) |
| 167 | goto exit_remove_fake; |
| 168 | |
| 169 | return 0; |
| 170 | |
| 171 | exit_remove_fake: |
| 172 | i2c_unregister_device(data->fake_client); |
| 173 | exit_kfree: |
| 174 | kfree(data); |
| 175 | return err; |
| 176 | } |
| 177 | |
| 178 | static int max6875_remove(struct i2c_client *client) |
| 179 | { |
| 180 | struct max6875_data *data = i2c_get_clientdata(client); |
| 181 | |
| 182 | i2c_unregister_device(data->fake_client); |
| 183 | |
| 184 | sysfs_remove_bin_file(&client->dev.kobj, &user_eeprom_attr); |
| 185 | kfree(data); |
| 186 | |
| 187 | return 0; |
| 188 | } |
| 189 | |
| 190 | static const struct i2c_device_id max6875_id[] = { |
| 191 | { "max6875", 0 }, |
| 192 | { } |
| 193 | }; |
| 194 | MODULE_DEVICE_TABLE(i2c, max6875_id); |
| 195 | |
| 196 | static struct i2c_driver max6875_driver = { |
| 197 | .driver = { |
| 198 | .name = "max6875", |
| 199 | }, |
| 200 | .probe = max6875_probe, |
| 201 | .remove = max6875_remove, |
| 202 | .id_table = max6875_id, |
| 203 | }; |
| 204 | |
| 205 | module_i2c_driver(max6875_driver); |
| 206 | |
| 207 | MODULE_AUTHOR("Ben Gardner <bgardner@wabtec.com>"); |
| 208 | MODULE_DESCRIPTION("MAX6875 driver"); |
| 209 | MODULE_LICENSE("GPL"); |