1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16#include <linux/i2c.h>
17#include <linux/init.h>
18#include <linux/kernel.h>
19#include <linux/mod_devicetable.h>
20#include <linux/module.h>
21#include <linux/mutex.h>
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38#define EE1004_ADDR_SET_PAGE 0x36
39#define EE1004_EEPROM_SIZE 512
40#define EE1004_PAGE_SIZE 256
41#define EE1004_PAGE_SHIFT 8
42
43
44
45
46
47static DEFINE_MUTEX(ee1004_bus_lock);
48static struct i2c_client *ee1004_set_page[2];
49static unsigned int ee1004_dev_count;
50static int ee1004_current_page;
51
52static const struct i2c_device_id ee1004_ids[] = {
53 { "ee1004", 0 },
54 { }
55};
56MODULE_DEVICE_TABLE(i2c, ee1004_ids);
57
58
59
60static ssize_t ee1004_eeprom_read(struct i2c_client *client, char *buf,
61 unsigned int offset, size_t count)
62{
63 int status;
64
65 if (count > I2C_SMBUS_BLOCK_MAX)
66 count = I2C_SMBUS_BLOCK_MAX;
67
68 if (unlikely(offset + count > EE1004_PAGE_SIZE))
69 count = EE1004_PAGE_SIZE - offset;
70
71 status = i2c_smbus_read_i2c_block_data_or_emulated(client, offset,
72 count, buf);
73 dev_dbg(&client->dev, "read %zu@%d --> %d\n", count, offset, status);
74
75 return status;
76}
77
78static ssize_t ee1004_read(struct file *filp, struct kobject *kobj,
79 struct bin_attribute *bin_attr,
80 char *buf, loff_t off, size_t count)
81{
82 struct device *dev = kobj_to_dev(kobj);
83 struct i2c_client *client = to_i2c_client(dev);
84 size_t requested = count;
85 int page;
86
87 if (unlikely(!count))
88 return count;
89
90 page = off >> EE1004_PAGE_SHIFT;
91 if (unlikely(page > 1))
92 return 0;
93 off &= (1 << EE1004_PAGE_SHIFT) - 1;
94
95
96
97
98
99 mutex_lock(&ee1004_bus_lock);
100
101 while (count) {
102 int status;
103
104
105 if (page != ee1004_current_page) {
106
107 status = i2c_smbus_write_byte(ee1004_set_page[page],
108 0x00);
109 if (status < 0) {
110 dev_err(dev, "Failed to select page %d (%d)\n",
111 page, status);
112 mutex_unlock(&ee1004_bus_lock);
113 return status;
114 }
115 dev_dbg(dev, "Selected page %d\n", page);
116 ee1004_current_page = page;
117 }
118
119 status = ee1004_eeprom_read(client, buf, off, count);
120 if (status < 0) {
121 mutex_unlock(&ee1004_bus_lock);
122 return status;
123 }
124 buf += status;
125 off += status;
126 count -= status;
127
128 if (off == EE1004_PAGE_SIZE) {
129 page++;
130 off = 0;
131 }
132 }
133
134 mutex_unlock(&ee1004_bus_lock);
135
136 return requested;
137}
138
139static const struct bin_attribute eeprom_attr = {
140 .attr = {
141 .name = "eeprom",
142 .mode = 0444,
143 },
144 .size = EE1004_EEPROM_SIZE,
145 .read = ee1004_read,
146};
147
148static int ee1004_probe(struct i2c_client *client,
149 const struct i2c_device_id *id)
150{
151 int err, cnr = 0;
152 const char *slow = NULL;
153
154
155 if (!i2c_check_functionality(client->adapter,
156 I2C_FUNC_SMBUS_READ_BYTE |
157 I2C_FUNC_SMBUS_READ_I2C_BLOCK)) {
158 if (i2c_check_functionality(client->adapter,
159 I2C_FUNC_SMBUS_READ_BYTE |
160 I2C_FUNC_SMBUS_READ_WORD_DATA))
161 slow = "word";
162 else if (i2c_check_functionality(client->adapter,
163 I2C_FUNC_SMBUS_READ_BYTE |
164 I2C_FUNC_SMBUS_READ_BYTE_DATA))
165 slow = "byte";
166 else
167 return -EPFNOSUPPORT;
168 }
169
170
171 mutex_lock(&ee1004_bus_lock);
172 if (++ee1004_dev_count == 1) {
173 for (cnr = 0; cnr < 2; cnr++) {
174 ee1004_set_page[cnr] = i2c_new_dummy(client->adapter,
175 EE1004_ADDR_SET_PAGE + cnr);
176 if (!ee1004_set_page[cnr]) {
177 dev_err(&client->dev,
178 "address 0x%02x unavailable\n",
179 EE1004_ADDR_SET_PAGE + cnr);
180 err = -EADDRINUSE;
181 goto err_clients;
182 }
183 }
184 } else if (i2c_adapter_id(client->adapter) !=
185 i2c_adapter_id(ee1004_set_page[0]->adapter)) {
186 dev_err(&client->dev,
187 "Driver only supports devices on a single I2C bus\n");
188 err = -EOPNOTSUPP;
189 goto err_clients;
190 }
191
192
193 err = i2c_smbus_read_byte(ee1004_set_page[0]);
194 if (err == -ENXIO) {
195
196 ee1004_current_page = 1;
197 } else if (err < 0) {
198
199 goto err_clients;
200 } else {
201
202 ee1004_current_page = 0;
203 }
204 dev_dbg(&client->dev, "Currently selected page: %d\n",
205 ee1004_current_page);
206 mutex_unlock(&ee1004_bus_lock);
207
208
209 err = sysfs_create_bin_file(&client->dev.kobj, &eeprom_attr);
210 if (err)
211 goto err_clients_lock;
212
213 dev_info(&client->dev,
214 "%u byte EE1004-compliant SPD EEPROM, read-only\n",
215 EE1004_EEPROM_SIZE);
216 if (slow)
217 dev_notice(&client->dev,
218 "Falling back to %s reads, performance will suffer\n",
219 slow);
220
221 return 0;
222
223 err_clients_lock:
224 mutex_lock(&ee1004_bus_lock);
225 err_clients:
226 if (--ee1004_dev_count == 0) {
227 for (cnr--; cnr >= 0; cnr--) {
228 i2c_unregister_device(ee1004_set_page[cnr]);
229 ee1004_set_page[cnr] = NULL;
230 }
231 }
232 mutex_unlock(&ee1004_bus_lock);
233
234 return err;
235}
236
237static int ee1004_remove(struct i2c_client *client)
238{
239 int i;
240
241 sysfs_remove_bin_file(&client->dev.kobj, &eeprom_attr);
242
243
244 mutex_lock(&ee1004_bus_lock);
245 if (--ee1004_dev_count == 0) {
246 for (i = 0; i < 2; i++) {
247 i2c_unregister_device(ee1004_set_page[i]);
248 ee1004_set_page[i] = NULL;
249 }
250 }
251 mutex_unlock(&ee1004_bus_lock);
252
253 return 0;
254}
255
256
257
258static struct i2c_driver ee1004_driver = {
259 .driver = {
260 .name = "ee1004",
261 },
262 .probe = ee1004_probe,
263 .remove = ee1004_remove,
264 .id_table = ee1004_ids,
265};
266
267static int __init ee1004_init(void)
268{
269 return i2c_add_driver(&ee1004_driver);
270}
271module_init(ee1004_init);
272
273static void __exit ee1004_exit(void)
274{
275 i2c_del_driver(&ee1004_driver);
276}
277module_exit(ee1004_exit);
278
279MODULE_DESCRIPTION("Driver for EE1004-compliant DDR4 SPD EEPROMs");
280MODULE_AUTHOR("Jean Delvare");
281MODULE_LICENSE("GPL");
282