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